feat: per-element deadline scheduling in dateObserver

[Copilot]

A single second-precision <relative-time> element drives the entire page to a 1 s tick. Every tick calls update() on every observed element — so 300 elements showing "3 months ago" each run a full elapsedTime() + #resolveFormat() + Intl.format() pass every second, producing identical output each time.

Approach

Keep the single shared timer but give each element its own next-due timestamp via a WeakMap<RelativeTimeElement, number>. Each tick skips elements whose deadline hasn't passed; after updating an element its deadline is reset to now + getUnitFactor(el). The next timer interval is the minimum remaining time across all observed elements.

Key details

• WeakMap not Map — deadlines are only looked up by key (we iterate this.elements), so no iteration over the map itself is needed and WeakMap gives better GC semantics.
• observe() during a tick — timeEl.update() calls observe(this) at the end of every update. The existing if (this.updating) return guard prevents clobbering the deadline the tick loop is about to set immediately after timeEl.update() returns. Attribute changes arriving outside a tick (the normal attributeChangedCallback → microtask → update() path) always re-enter observe() with updating = false, so they correctly recompute the deadline.
• Per-element error isolation — wraps each timeEl.update() call in try/catch, rethrowing async, so one throwing element cannot abort the tick or skip the reschedule.

for (const timeEl of this.elements) {
  let due = this.deadlines.get(timeEl) ?? 0
  if (due <= now) {
    try { timeEl.update() } catch (error) { setTimeout(() => { throw error }) }
    due = now + getUnitFactor(timeEl)
    this.deadlines.set(timeEl, due)
  }
  nearest = Math.min(nearest, due - now)
}

Benchmark

1 second-precision element + 300 month-old elements, 10 s simulated time:

	update() calls
Before	3,311
After	10

Tests added

• Slow elements are not re-formatted on fast-cadence ticks
• Slow elements still update when their own deadline passes
• First render is synchronous on connectedCallback
• datetime change resets the deadline to the fast cadence
• Error in one element does not prevent others from updating