Problem

src/lazy-define.ts has several performance and correctness issues that need to be addressed:

1. Race condition: duplicate callback firing (High)

dynamicElements.delete(tagName) runs inside the requestAnimationFrame callback, so a second scan() on a different element can iterate the same tag before deletion, causing callbacks to fire multiple times.

Fix: Introduce a synchronous triggered set. triggerTag() atomically claims a tag name before any async work, so no concurrent scan can double-fire. Delete from pending before awaiting the strategy.

2. IntersectionObserver leak when no elements match (High)

In the visible() strategy, if document.querySelectorAll(tagName) returns no elements, the IntersectionObserver is created but never observes anything, so the promise never resolves and the observer/closure are retained forever.

Fix: Instead of resolving immediately (which would defeat the purpose of visible for not-yet-rendered elements), use a MutationObserver fallback to wait for the element to appear in the DOM before creating the IntersectionObserver:

function visible(tagName: string): Promise<void> {
  return new Promise<void>(resolve => {
    function tryObserve() {
      const elements = document.querySelectorAll(tagName)
      if (elements.length === 0) return false

      const observer = new IntersectionObserver(
        entries => {
          for (const entry of entries) {
            if (entry.isIntersecting) {
              resolve()
              observer.disconnect()
              return
            }
          }
        },
        {
          rootMargin: '0px 0px 256px 0px',
          threshold: 0.01
        }
      )
      for (const el of elements) observer.observe(el)
      return true
    }

    if (tryObserve()) return

    const mo = new MutationObserver(() => {
      if (tryObserve()) mo.disconnect()
    })
    mo.observe(document.documentElement, {subtree: true, childList: true})
  })
}

3. Redundant observe() calls (Medium)

No guard against calling observe() on the same target multiple times. The same MutationObserver would observe the same subtree redundantly, causing duplicate mutation records and duplicate scan() calls.

Fix: Use a WeakSet<ElementLike> to track already-observed targets. Re-calling observe() still triggers a scan() (to pick up newly registered tags) but skips the duplicate observer.observe().

4. MutationObserver is never disconnected (Medium)

Even after every registered tag has been triggered and pending is empty, the observer remains connected to the document, receiving and discarding every DOM mutation.

Fix: Disconnect the observer when pending is empty after the last tag is triggered. Reconnect when new tags are registered via lazyDefine.

5. No error handling on callbacks (Medium)

If any callback throws, the rejection is unhandled.

Fix: Add .catch(reportError) (or equivalent) on callback promises to surface errors without killing other callbacks.

6. Late registration after trigger (Medium)

If lazyDefine is called for a tag that has already been found and triggered, the callback is added to a set that will never be consumed.

Fix: In lazyDefine, check the triggered set and immediately schedule the callback via Promise.resolve().then(cb) for already-triggered tags, preserving the async-microtask contract.

7. Scan optimization (Low-Medium)

Every added node iterates every registered tag name.

Fix: Early-exit when pending.size === 0, snapshot keys with [...pending.keys()] for safe in-loop mutation so triggered tags are removed and subsequent scans iterate fewer tags.

Requirements

• The public API (lazyDefine and observe exports) must remain unchanged — this should be a drop-in replacement.
• Keep the PR as a draft when it's ready.
• Update or add tests if applicable to cover the race condition and leak fixes.
• The file to modify is src/lazy-define.ts.