stitchkit 0.94.0 → 0.94.1

package/dist/entrypoints/tracking.js

@@ -1,9 +1,10 @@
 import {
   ApiError
-} from "../index-zeemqhqx.js";
+} from "../index-v260df89.js";
 import {
   defineContract
-} from "../index-gyr48nzg.js";
+} from "../index-k30h66yd.js";
+import"../index-4gcnakhx.js";
 import"../index-zcgf3gqf.js";
 import"../index-kzfs85xp.js";
 import"../index-hffjpmq9.js";
@@ -258,6 +259,69 @@ function resolveTrackedClick(target, { origin, attributes = {}, isAction = () =>
   }
   return result.interaction || result.click || result.outbound ? result : null;
 }
+// src/tracking/client-listeners.ts
+function wireTrackingListeners(deps) {
+  const { host, builtin } = deps;
+  const unsubscribe = [];
+  const renewThenFlush = () => void deps.renewVisit().then(() => deps.flushOutbox());
+  unsubscribe.push(host.on("online", renewThenFlush));
+  unsubscribe.push(host.interval(() => void deps.flushOutbox(), deps.heartbeatMs));
+  let hiddenAt = null;
+  let lastLeaveAt = Number.NEGATIVE_INFINITY;
+  const onHide = () => {
+    const at = host.now();
+    if (at - lastLeaveAt < 1000)
+      return;
+    lastLeaveAt = at;
+    deps.sendOnUnload(deps.leaveDraft(deps.currentPage()));
+    deps.releaseLease();
+  };
+  unsubscribe.push(host.on("pagehide", onHide));
+  unsubscribe.push(host.on("visibilitychange", () => {
+    if (!host.visible()) {
+      hiddenAt = host.wallClock();
+      onHide();
+      return;
+    }
+    deps.meter.checkpoint();
+    if (hiddenAt !== null && host.wallClock() - hiddenAt >= deps.renewAfterHiddenMs) {
+      renewThenFlush();
+    }
+    hiddenAt = null;
+  }));
+  unsubscribe.push(host.interval(() => {
+    deps.send([deps.draft(builtin.heartbeat, { ...deps.meter.heartbeat(host.visible()) })]);
+  }, deps.heartbeatMs));
+  unsubscribe.push(host.on("scroll", () => deps.scroll.record(host.scrollDepth())));
+  unsubscribe.push(host.interval(() => {
+    for (const milestone of deps.scroll.observe(host.scrollDepth())) {
+      deps.send([deps.draft(builtin.scrollDepth, { maxPercent: milestone })]);
+    }
+  }, 2000));
+  unsubscribe.push(host.onClick((target) => {
+    const click = resolveTrackedClick(target, {
+      origin: host.page().origin,
+      attributes: deps.clickAttributes,
+      isAction: deps.isAction
+    });
+    if (!click)
+      return;
+    const drafts = [];
+    if (click.interaction)
+      drafts.push(deps.draft(builtin.interaction, { ...click.interaction }));
+    if (click.click)
+      drafts.push(deps.draft(builtin.click, { ...click.click }));
+    if (click.outbound)
+      drafts.push(deps.draft(builtin.outboundClick, { ...click.outbound }));
+    if (click.leavesPage)
+      for (const item of drafts)
+        deps.sendOnUnload(item);
+    else
+      deps.send(drafts);
+  }));
+  return unsubscribe;
+}
+
 // src/tracking/delivery.ts
 function isRetryable(error) {
   return ApiError.is(error) && (error.status === 0 || error.status >= 500);
@@ -295,40 +359,6 @@ async function deliverTrackingBatch({
   return "failed";
 }
 
-// src/tracking/scroll.ts
-function scrollDepthPercent(view) {
-  const scrollable = view.scrollHeight - view.innerHeight;
-  if (scrollable <= 0)
-    return 0;
-  return Math.max(0, Math.min(100, Math.round(view.scrollY / scrollable * 100)));
-}
-function createScrollMilestones(milestones = [25, 50, 75, 100]) {
-  const sorted = [...milestones].sort((a, b) => a - b);
-  let deepest = 0;
-  const fired = new Set;
-  return {
-    record(percent) {
-      deepest = Math.max(deepest, percent);
-    },
-    observe(percent) {
-      deepest = Math.max(deepest, percent);
-      const reached = [];
-      for (const milestone of sorted) {
-        if (deepest >= milestone && !fired.has(milestone)) {
-          fired.add(milestone);
-          reached.push(milestone);
-        }
-      }
-      return reached;
-    },
-    max: () => deepest,
-    reset() {
-      deepest = 0;
-      fired.clear();
-    }
-  };
-}
-
 // src/tracking/sequence-reserve.ts
 function createSequenceReserve(reserve, options = {}) {
   const blockSize = options.blockSize ?? 16;
@@ -376,6 +406,185 @@ function createSequenceReserve(reserve, options = {}) {
   };
 }
 
+// src/tracking/client-visit.ts
+function bootstrapTrackingVisit(deps, renew) {
+  const { visit, config, host, outbox, sequences, captureAttribution, fail } = deps;
+  if (!renew && visit.visitId && visit.browserStreamId)
+    return Promise.resolve(visit.visitId);
+  if (visit.bootstrapping)
+    return visit.bootstrapping;
+  const run = (async () => {
+    try {
+      const health = outbox ? await outbox.health() : { state: "unavailable", queued: 0, dropped: 0 };
+      const wasAvailable = visit.outboxAvailable;
+      visit.outboxAvailable = health.state === "available";
+      if (visit.outboxAvailable && !wasAvailable && !sequences.shared())
+        sequences.reset();
+      visit.browserStreamId = visit.outboxAvailable && outbox ? await outbox.streamId() : visit.browserStreamId ?? host.randomUUID();
+      await sequences.refill();
+      const page = host.page();
+      const touch = captureAttribution(page.search, page.pathname);
+      const response = await config.bootstrap({
+        browserStreamId: visit.browserStreamId,
+        previousVisitId: visit.visitId ?? undefined,
+        origin: page.origin,
+        landingPath: page.pathname,
+        referrer: page.referrer || undefined,
+        utm: touch?.currentTouch.utm?.source ? touch.currentTouch.utm : undefined,
+        displayMode: page.displayMode,
+        screenWidth: page.screenWidth,
+        screenHeight: page.screenHeight,
+        buildId: config.buildId,
+        outboxState: health.state,
+        outboxQueued: health.queued,
+        outboxDropped: health.dropped
+      });
+      visit.visitId = response.visitId;
+      config.onVisit?.(visit.visitId);
+      return visit.visitId;
+    } catch (error) {
+      fail("visit bootstrap", error);
+      return null;
+    } finally {
+      visit.bootstrapping = null;
+    }
+  })();
+  visit.bootstrapping = run;
+  return run;
+}
+function createOutboxFlusher(deps) {
+  const { outbox } = deps;
+  let flushing = null;
+  let queued = null;
+  const flushOutbox = () => {
+    if (!outbox || !deps.isAvailable())
+      return Promise.resolve();
+    if (flushing) {
+      queued ??= flushing.then(() => {
+        queued = null;
+        return flushOutbox();
+      });
+      return queued;
+    }
+    flushing = (async () => {
+      try {
+        if (!await outbox.acquireLease(deps.owner))
+          return;
+        const batch = await outbox.readBatch(deps.batchSize);
+        if (batch.length === 0)
+          return;
+        const response = await deps.deliver(batch);
+        if (response) {
+          await outbox.acknowledge(response.dispositions.map((item) => item.eventId));
+        }
+      } catch (error) {
+        deps.fail("outbox flush", error);
+      } finally {
+        flushing = null;
+      }
+    })();
+    return flushing;
+  };
+  return flushOutbox;
+}
+function createVisitSequences(outbox, visit, options, fail) {
+  return createSequenceReserve((count) => {
+    if (!outbox || !visit.outboxAvailable)
+      return Promise.reject(new Error("outbox unavailable"));
+    return outbox.reserveSequences(count);
+  }, {
+    ...options,
+    onUnavailable: outbox ? (error) => {
+      visit.outboxAvailable = false;
+      fail("sequence reservation", error);
+    } : undefined
+  });
+}
+function pageAttribution(host, storage, referrerMap, search, pathname) {
+  const page = host.page();
+  return resolveAttribution({
+    search,
+    pathname,
+    referrer: page.referrer,
+    hostname: page.hostname,
+    storage,
+    referrerMap,
+    now: host.wallClock()
+  });
+}
+function pageViewDraft(host, type, pathname, previous) {
+  const page = host.page();
+  return {
+    type,
+    page: pathname,
+    metadata: {
+      title: page.title,
+      screenWidth: page.viewportWidth,
+      screenHeight: page.viewportHeight,
+      referrer: previous ? undefined : page.referrer || undefined
+    },
+    clientTimestamp: host.wallClock()
+  };
+}
+async function materializeAll(drafts, materialize, sequences) {
+  const events = [];
+  for (const draft of drafts) {
+    let event = materialize(draft);
+    if (!event) {
+      await sequences.refill();
+      event = materialize(draft);
+    }
+    if (event)
+      events.push(event);
+  }
+  return events;
+}
+async function deliverTrackedEvents(config, request, fail) {
+  let response = null;
+  const outcome = await deliverTrackingBatch({
+    request: async () => {
+      response = await config.deliver(request);
+    },
+    onUnauthorized: config.onUnauthorized,
+    onFailure: (error) => fail("event delivery", error)
+  });
+  return outcome === "delivered" ? response : null;
+}
+
+// src/tracking/scroll.ts
+function scrollDepthPercent(view) {
+  const scrollable = view.scrollHeight - view.innerHeight;
+  if (scrollable <= 0)
+    return 0;
+  return Math.max(0, Math.min(100, Math.round(view.scrollY / scrollable * 100)));
+}
+function createScrollMilestones(milestones = [25, 50, 75, 100]) {
+  const sorted = [...milestones].sort((a, b) => a - b);
+  let deepest = 0;
+  const fired = new Set;
+  return {
+    record(percent) {
+      deepest = Math.max(deepest, percent);
+    },
+    observe(percent) {
+      deepest = Math.max(deepest, percent);
+      const reached = [];
+      for (const milestone of sorted) {
+        if (deepest >= milestone && !fired.has(milestone)) {
+          fired.add(milestone);
+          reached.push(milestone);
+        }
+      }
+      return reached;
+    },
+    max: () => deepest,
+    reset() {
+      deepest = 0;
+      fired.clear();
+    }
+  };
+}
+
 // src/tracking/visible-time.ts
 function createVisibleTimeMeter(options = {}) {
   const now = options.now ?? (() => performance.now());
@@ -421,154 +630,63 @@ function chunk(items, size) {
     chunks.push(items.slice(at, at + size));
   return chunks;
 }
-function createTrackingClient(config) {
+function unloadBeacon(unloadUrl) {
+  return (request) => unloadUrl === undefined ? false : sendUnloadBeacon(unloadUrl, JSON.stringify(request));
+}
+function currentUtmOf(attribution) {
+  return attribution?.currentTouch.utm?.source ? attribution.currentTouch.utm : undefined;
+}
+function trackingTimings(config) {
   if (typeof config.buildId !== "string" || config.buildId.length === 0) {
     throw new Error('[stitchkit] tracking client requires a buildId — a git SHA or "dev"');
   }
+  return {
+    heartbeatMs: config.heartbeatMs ?? 30000,
+    renewAfterHiddenMs: config.renewAfterHiddenMs ?? 30 * 60 * 1000,
+    pendingLimit: config.pendingLimit ?? 100,
+    batchSize: config.batchSize ?? 50
+  };
+}
+function createTrackingClient(config) {
   const { host, builtin, outbox } = config;
-  const heartbeatMs = config.heartbeatMs ?? 30000;
-  const renewAfterHiddenMs = config.renewAfterHiddenMs ?? 30 * 60 * 1000;
-  const pendingLimit = config.pendingLimit ?? 100;
-  const batchSize = config.batchSize ?? 50;
+  const { heartbeatMs, renewAfterHiddenMs, pendingLimit, batchSize } = trackingTimings(config);
   const fail = config.onFailure ?? (() => {
     return;
   });
   const decorate = config.decorate ?? ((event) => event);
-  const unload = config.unload ?? ((request) => config.unloadUrl === undefined ? false : sendUnloadBeacon(config.unloadUrl, JSON.stringify(request)));
-  let browserStreamId = null;
-  let visitId = null;
-  let outboxAvailable = outbox !== undefined;
-  let bootstrapping = null;
+  const unload = config.unload ?? unloadBeacon(config.unloadUrl);
+  const visit = {
+    browserStreamId: null,
+    visitId: null,
+    outboxAvailable: outbox !== undefined,
+    bootstrapping: null
+  };
   let pending = [];
   let currentPage = null;
   let attribution = null;
   let running = 0;
   const flushOwner = host.randomUUID();
-  const meter = createVisibleTimeMeter({
-    now: () => host.now(),
-    wallClock: () => host.wallClock(),
-    randomUUID: () => host.randomUUID()
-  });
+  const meter = createVisibleTimeMeter(host);
   const scroll = createScrollMilestones(config.scrollMilestones);
-  const sequences = createSequenceReserve((count) => {
-    if (!outbox || !outboxAvailable)
-      return Promise.reject(new Error("outbox unavailable"));
-    return outbox.reserveSequences(count);
-  }, {
-    ...config.sequence,
-    onUnavailable: outbox ? (error) => {
-      outboxAvailable = false;
-      fail("sequence reservation", error);
-    } : undefined
-  });
-  const currentUtm = () => attribution?.currentTouch.utm?.source ? attribution.currentTouch.utm : undefined;
+  const sequences = createVisitSequences(outbox, visit, config.sequence, fail);
   const captureAttribution = (search, pathname) => {
     if (!host.storage)
       return null;
-    const page = host.page();
-    attribution = resolveAttribution({
-      search,
-      pathname,
-      referrer: page.referrer,
-      hostname: page.hostname,
-      storage: host.storage,
-      referrerMap: config.referrerMap,
-      now: host.wallClock()
-    });
+    attribution = pageAttribution(host, host.storage, config.referrerMap, search, pathname);
     return attribution;
   };
-  const bootstrapVisit = (renew = false) => {
-    if (!renew && visitId && browserStreamId)
-      return Promise.resolve(visitId);
-    if (bootstrapping)
-      return bootstrapping;
-    const run = (async () => {
-      try {
-        const health = outbox ? await outbox.health() : { state: "unavailable", queued: 0, dropped: 0 };
-        const wasAvailable = outboxAvailable;
-        outboxAvailable = health.state === "available";
-        if (outboxAvailable && !wasAvailable && !sequences.shared())
-          sequences.reset();
-        browserStreamId = outboxAvailable && outbox ? await outbox.streamId() : browserStreamId ?? host.randomUUID();
-        await sequences.refill();
-        const page = host.page();
-        const touch = captureAttribution(page.search, page.pathname);
-        const response = await config.bootstrap({
-          browserStreamId,
-          previousVisitId: visitId ?? undefined,
-          origin: page.origin,
-          landingPath: page.pathname,
-          referrer: page.referrer || undefined,
-          utm: touch?.currentTouch.utm?.source ? touch.currentTouch.utm : undefined,
-          displayMode: page.displayMode,
-          screenWidth: page.screenWidth,
-          screenHeight: page.screenHeight,
-          buildId: config.buildId,
-          outboxState: health.state,
-          outboxQueued: health.queued,
-          outboxDropped: health.dropped
-        });
-        visitId = response.visitId;
-        config.onVisit?.(visitId);
-        return visitId;
-      } catch (error) {
-        fail("visit bootstrap", error);
-        return null;
-      } finally {
-        bootstrapping = null;
-      }
-    })();
-    bootstrapping = run;
-    return run;
-  };
-  const deliver = async (events) => {
-    let response = null;
-    const outcome = await deliverTrackingBatch({
-      request: async () => {
-        response = await config.deliver({
-          buildId: config.buildId,
-          events,
-          utm: currentUtm()
-        });
-      },
-      onUnauthorized: config.onUnauthorized,
-      onFailure: (error) => fail("event delivery", error)
-    });
-    return outcome === "delivered" ? response : null;
-  };
-  let flushing = null;
-  let queued = null;
-  const flushOutbox = () => {
-    if (!outbox || !outboxAvailable)
-      return Promise.resolve();
-    if (flushing) {
-      queued ??= flushing.then(() => {
-        queued = null;
-        return flushOutbox();
-      });
-      return queued;
-    }
-    flushing = (async () => {
-      try {
-        if (!await outbox.acquireLease(flushOwner))
-          return;
-        const batch = await outbox.readBatch(batchSize);
-        if (batch.length === 0)
-          return;
-        const response = await deliver(batch);
-        if (response) {
-          await outbox.acknowledge(response.dispositions.map((item) => item.eventId));
-        }
-      } catch (error) {
-        fail("outbox flush", error);
-      } finally {
-        flushing = null;
-      }
-    })();
-    return flushing;
-  };
+  const bootstrapVisit = (renew = false) => bootstrapTrackingVisit({ visit, config, host, outbox, sequences, captureAttribution, fail }, renew);
+  const deliver = (events) => deliverTrackedEvents(config, { buildId: config.buildId, events, utm: currentUtmOf(attribution) }, fail);
+  const flushOutbox = createOutboxFlusher({
+    outbox,
+    isAvailable: () => visit.outboxAvailable,
+    owner: flushOwner,
+    batchSize,
+    deliver,
+    fail
+  });
   const materialize = (draft2) => {
-    if (!visitId || !browserStreamId)
+    if (!visit.visitId || !visit.browserStreamId)
       return null;
     const sequence = sequences.take();
     if (sequence === null)
@@ -576,13 +694,13 @@ function createTrackingClient(config) {
     return decorate({
       ...draft2,
       eventId: host.randomUUID(),
-      visitId,
-      browserStreamId,
+      visitId: visit.visitId,
+      browserStreamId: visit.browserStreamId,
       browserSequence: sequence
     });
   };
   const persistAndFlush = async (events) => {
-    if (!outbox || !outboxAvailable) {
+    if (!outbox || !visit.outboxAvailable) {
       for (const batch of chunk(events, batchSize))
         await deliver(batch);
       return;
@@ -601,7 +719,7 @@ function createTrackingClient(config) {
       send(drafts);
   };
   const send = (drafts) => {
-    if (!visitId || !browserStreamId) {
+    if (!visit.visitId || !visit.browserStreamId) {
       pending = [...pending, ...drafts].slice(-pendingLimit);
       bootstrapVisit().then((issued) => {
         if (issued)
@@ -609,20 +727,10 @@ function createTrackingClient(config) {
       });
       return;
     }
-    (async () => {
-      const events = [];
-      for (const draft2 of drafts) {
-        let event = materialize(draft2);
-        if (!event) {
-          await sequences.refill();
-          event = materialize(draft2);
-        }
-        if (event)
-          events.push(event);
-      }
+    materializeAll(drafts, materialize, sequences).then(async (events) => {
       if (events.length > 0)
         await persistAndFlush(events);
-    })();
+    });
   };
   const sendOnUnload = (draft2) => {
     const event = materialize(draft2);
@@ -630,26 +738,19 @@ function createTrackingClient(config) {
       send([draft2]);
       return;
     }
-    unload({ buildId: config.buildId, events: [event], utm: currentUtm() });
-    if (outbox && outboxAvailable) {
+    unload({ buildId: config.buildId, events: [event], utm: currentUtmOf(attribution) });
+    if (outbox && visit.outboxAvailable)
       outbox.enqueue(event).catch((error) => fail("unload event persistence", error));
-    }
   };
-  const draft = (type, metadata) => ({
-    type,
-    page: currentPage ?? host.page().pathname,
-    metadata,
-    clientTimestamp: host.wallClock()
-  });
-  const leaveDraft = (page) => ({
-    type: builtin.pageLeave,
-    page,
-    metadata: { ...meter.cut(), scrollDepthPercent: scroll.max() },
-    clientTimestamp: host.wallClock()
-  });
-  function track(type, metadata) {
-    send([draft(type, metadata === undefined ? undefined : asMetadata(metadata))]);
-  }
+  const draft = (type, metadata) => {
+    const page = currentPage ?? host.page().pathname;
+    return { type, page, metadata, clientTimestamp: host.wallClock() };
+  };
+  const leaveDraft = (page) => {
+    const metadata = { ...meter.cut(), scrollDepthPercent: scroll.max() };
+    return { type: builtin.pageLeave, page, metadata, clientTimestamp: host.wallClock() };
+  };
+  const track = (type, metadata) => send([draft(type, metadata === undefined ? undefined : asMetadata(metadata))]);
   const onNavigate = (pathname, search) => {
     captureAttribution(search, pathname);
     const previous = currentPage;
@@ -660,89 +761,39 @@ function createTrackingClient(config) {
     currentPage = pathname;
     meter.checkpoint();
     scroll.reset();
-    const page = host.page();
-    send([
-      {
-        type: builtin.pageView,
-        page: pathname,
-        metadata: {
-          title: page.title,
-          screenWidth: page.viewportWidth,
-          screenHeight: page.viewportHeight,
-          referrer: previous ? undefined : page.referrer || undefined
-        },
-        clientTimestamp: host.wallClock()
-      }
-    ]);
+    send([pageViewDraft(host, builtin.pageView, pathname, previous)]);
   };
   const start = () => {
     const generation = ++running;
-    const unsubscribe = [];
     bootstrapVisit().then((issued) => {
       if (!issued || generation !== running)
         return;
       drainPending();
       flushOutbox();
     });
-    const renewThenFlush = () => void bootstrapVisit(true).then(() => flushOutbox());
-    unsubscribe.push(host.on("online", renewThenFlush));
-    unsubscribe.push(host.interval(() => void flushOutbox(), heartbeatMs));
-    let hiddenAt = null;
-    let lastLeaveAt = Number.NEGATIVE_INFINITY;
-    const onHide = () => {
-      const at = host.now();
-      if (at - lastLeaveAt < 1000)
-        return;
-      lastLeaveAt = at;
-      sendOnUnload(leaveDraft(currentPage ?? host.page().pathname));
-      if (outbox && outboxAvailable)
-        outbox.releaseLease(flushOwner).catch(() => {
-          return;
-        });
-    };
-    unsubscribe.push(host.on("pagehide", onHide));
-    unsubscribe.push(host.on("visibilitychange", () => {
-      if (!host.visible()) {
-        hiddenAt = host.wallClock();
-        onHide();
-        return;
-      }
-      meter.checkpoint();
-      if (hiddenAt !== null && host.wallClock() - hiddenAt >= renewAfterHiddenMs) {
-        renewThenFlush();
-      }
-      hiddenAt = null;
-    }));
-    unsubscribe.push(host.interval(() => {
-      send([draft(builtin.heartbeat, { ...meter.heartbeat(host.visible()) })]);
-    }, heartbeatMs));
-    unsubscribe.push(host.on("scroll", () => scroll.record(host.scrollDepth())));
-    unsubscribe.push(host.interval(() => {
-      for (const milestone of scroll.observe(host.scrollDepth())) {
-        send([draft(builtin.scrollDepth, { maxPercent: milestone })]);
-      }
-    }, 2000));
-    unsubscribe.push(host.onClick((target) => {
-      const click = resolveTrackedClick(target, {
-        origin: host.page().origin,
-        attributes: config.clickAttributes,
-        isAction: config.isAction
-      });
-      if (!click)
-        return;
-      const drafts = [];
-      if (click.interaction)
-        drafts.push(draft(builtin.interaction, { ...click.interaction }));
-      if (click.click)
-        drafts.push(draft(builtin.click, { ...click.click }));
-      if (click.outbound)
-        drafts.push(draft(builtin.outboundClick, { ...click.outbound }));
-      if (click.leavesPage)
-        for (const item of drafts)
-          sendOnUnload(item);
-      else
-        send(drafts);
-    }));
+    const unsubscribe = wireTrackingListeners({
+      host,
+      builtin,
+      heartbeatMs,
+      renewAfterHiddenMs,
+      meter,
+      scroll,
+      draft,
+      leaveDraft,
+      send,
+      sendOnUnload,
+      flushOutbox,
+      renewVisit: () => bootstrapVisit(true),
+      currentPage: () => currentPage ?? host.page().pathname,
+      releaseLease: () => {
+        if (outbox && visit.outboxAvailable)
+          outbox.releaseLease(flushOwner).catch(() => {
+            return;
+          });
+      },
+      clickAttributes: config.clickAttributes,
+      isAction: config.isAction
+    });
     return () => {
       running += 1;
       for (const off of unsubscribe.splice(0))
@@ -753,8 +804,8 @@ function createTrackingClient(config) {
     track,
     onNavigate,
     start,
-    visitId: () => visitId,
-    browserStreamId: () => browserStreamId,
+    visitId: () => visit.visitId,
+    browserStreamId: () => visit.browserStreamId,
     attribution: () => attribution
   };
 }