@scalebun-release/web 2.2.2

package/dist/features/journey/JourneyFeature.js

@@ -0,0 +1,71 @@
+import { setUiStateReader, uuid, now, getReplayCoord } from '../../core/index.js';
+import { NavigationTracker } from './NavigationTracker.js';
+import { uiStateSignature } from './uiState.js';
+import { InteractionTracker } from './InteractionTracker.js';
+export class JourneyFeature {
+    constructor() {
+        this.name = 'journey';
+        this.ctx = null;
+        this.active = false;
+    }
+    get isActive() {
+        return this.active;
+    }
+    setup(ctx) {
+        this.ctx = ctx;
+        if (typeof window === 'undefined' || typeof document === 'undefined')
+            return;
+        this.nav = new NavigationTracker((from, to) => this.emit('SCREEN_VIEW', { from, to }, undefined, to));
+        /**
+         * Hand the state reader to the shared cell in core, so the LAZY replay recorder can take a
+         * keyframe when the signature changes without importing this module and dragging it into the
+         * eager bundle. Measured: a direct import from the recorder costs 56-59 B of eager budget
+         * against 97 B of headroom; this costs the cell. See core/uiStateReader.
+         */
+        setUiStateReader(uiStateSignature);
+        this.interactions = new InteractionTracker(
+        /* The interaction's OWN route wins. It was pinned at pointerdown; `currentPath()` here runs
+           after the dead-click window and therefore after any navigation the click caused. Falling
+           back keeps a caller that pins nothing working exactly as before. */
+        (name, data, label, interaction) => this.emit(name, data, label, interaction?.route ?? currentPath(), interaction), 
+        // Label masking is opt-IN (`privacy.maskEventText`). Off by default so USER_ACTION rows carry the
+        // real element text and group per element instead of collapsing by text shape.
+        { maskText: ctx.maskEventText === true }, (reason) => this.ctx?.signal(reason));
+        this.nav.start();
+        this.interactions.start();
+        this.active = true;
+    }
+    emit(name, props, label, screenName, interaction) {
+        // Heatmaps 2.0 (H5) — stamp WHERE the replay was when this happened, so a heatmap hotspot (or friction
+        // click) deep-links to the EXACT replay frame, not just the session. Cheap (a getter + spread); only
+        // present when replay is producing frames (undefined otherwise). Closes the journey↔replay gap that
+        // left the richest heatmap signal (clicks + rage/dead) without a frame coordinate.
+        const replay = props.replayCoord ? undefined : getReplayCoord();
+        const item = {
+            kind: 'event',
+            name,
+            props: replay ? { ...props, replayCoord: replay } : props,
+            label,
+            screenName: screenName ?? currentPath(),
+            eventId: `evt_${uuid()}`,
+            timestamp: interaction?.timestamp ?? now(),
+            interactionId: interaction?.interactionId,
+            interactionProtocol: interaction ? 1 : undefined,
+        };
+        this.ctx?.emit(item);
+    }
+    teardown() {
+        this.nav?.stop();
+        this.interactions?.stop();
+        this.active = false;
+    }
+}
+function currentPath() {
+    try {
+        return typeof location !== 'undefined' ? location.pathname : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=JourneyFeature.js.map

package/dist/features/journey/JourneyFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JourneyFeature.js","sourceRoot":"","sources":["../../../src/features/journey/JourneyFeature.ts"],"names":[],"mappings":"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"}

package/dist/features/journey/NavigationTracker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tracks route changes → one SCREEN_VIEW per navigation. Navigation API (Baseline 2026) + a
+ * history.pushState/replaceState patch fallback (Safari/older) + initial page-view + bfcache pageshow.
+ * Guards prerendering (don't log a page the user never sees) and dedups identical consecutive routes.
+ */
+export declare class NavigationTracker {
+    private readonly onScreen;
+    private last;
+    private cleanup;
+    constructor(onScreen: (from: string, to: string) => void);
+    start(): void;
+    private begin;
+    private check;
+    stop(): void;
+}
+//# sourceMappingURL=NavigationTracker.d.ts.map

package/dist/features/journey/NavigationTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationTracker.d.ts","sourceRoot":"","sources":["../../../src/features/journey/NavigationTracker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAHrC,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,OAAO,CAAyB;gBAEX,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI;IAEzE,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,KAAK;IA2Cb,OAAO,CAAC,KAAK;IAQb,IAAI,IAAI,IAAI;CAIb"}

package/dist/features/journey/NavigationTracker.js

@@ -0,0 +1,92 @@
+/**
+ * Tracks route changes → one SCREEN_VIEW per navigation. Navigation API (Baseline 2026) + a
+ * history.pushState/replaceState patch fallback (Safari/older) + initial page-view + bfcache pageshow.
+ * Guards prerendering (don't log a page the user never sees) and dedups identical consecutive routes.
+ */
+export class NavigationTracker {
+    constructor(onScreen) {
+        this.onScreen = onScreen;
+        this.last = '';
+        this.cleanup = [];
+    }
+    start() {
+        if (typeof window === 'undefined')
+            return;
+        // Speculation-Rules / prerender trap: wait until the page is actually shown.
+        if (typeof document !== 'undefined' && document.prerendering) {
+            const onShow = () => this.begin();
+            document.addEventListener('prerenderingchange', onShow, { once: true });
+            this.cleanup.push(() => document.removeEventListener('prerenderingchange', onShow));
+            return;
+        }
+        this.begin();
+    }
+    begin() {
+        this.last = path();
+        this.onScreen('', this.last); // initial page view
+        const nav = window.navigation;
+        if (nav && typeof nav.addEventListener === 'function') {
+            const onNav = (e) => {
+                const dest = e.destination?.url;
+                this.check(dest ? safePath(dest) : path());
+            };
+            nav.addEventListener('navigate', onNav);
+            this.cleanup.push(() => nav.removeEventListener('navigate', onNav));
+        }
+        // history patch fallback (SPA routers that don't trigger the Navigation API).
+        const h = history;
+        const origPush = h.pushState;
+        const origReplace = h.replaceState;
+        const check = () => this.check();
+        h.pushState = function (...args) {
+            const r = origPush.apply(this, args);
+            check();
+            return r;
+        };
+        h.replaceState = function (...args) {
+            const r = origReplace.apply(this, args);
+            check();
+            return r;
+        };
+        this.cleanup.push(() => {
+            h.pushState = origPush;
+            h.replaceState = origReplace;
+        });
+        const onPop = () => this.check();
+        window.addEventListener('popstate', onPop);
+        window.addEventListener('pageshow', onPop);
+        this.cleanup.push(() => {
+            window.removeEventListener('popstate', onPop);
+            window.removeEventListener('pageshow', onPop);
+        });
+    }
+    check(to = path()) {
+        if (to && to !== this.last) {
+            const from = this.last;
+            this.last = to;
+            this.onScreen(from, to);
+        }
+    }
+    stop() {
+        for (const c of this.cleanup)
+            c();
+        this.cleanup = [];
+    }
+}
+function path() {
+    try {
+        return typeof location !== 'undefined' ? location.pathname : '';
+    }
+    catch {
+        return '';
+    }
+}
+function safePath(url) {
+    try {
+        return new URL(url).pathname;
+    }
+    catch {
+        return path();
+    }
+}
+//# sourceMappingURL=NavigationTracker.js.map

package/dist/features/journey/NavigationTracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NavigationTracker.js","sourceRoot":"","sources":["../../../src/features/journey/NavigationTracker.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,iBAAiB;IAI5B,YAA6B,QAA4C;QAA5C,aAAQ,GAAR,QAAQ,CAAoC;QAHjE,SAAI,GAAG,EAAE,CAAC;QACV,YAAO,GAAsB,EAAE,CAAC;IAEoC,CAAC;IAE7E,KAAK;QACH,IAAI,OAAO,MAAM,KAAK,WAAW;YAAE,OAAO;QAC1C,6EAA6E;QAC7E,IAAI,OAAO,QAAQ,KAAK,WAAW,IAAK,QAAkD,CAAC,YAAY,EAAE,CAAC;YACxG,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;YAClC,QAAQ,CAAC,gBAAgB,CAAC,oBAAoB,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YACxE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC,CAAC;YACpF,OAAO;QACT,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;IAEO,KAAK;QACX,IAAI,CAAC,IAAI,GAAG,IAAI,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,oBAAoB;QAElD,MAAM,GAAG,GAAI,MAAkD,CAAC,UAAU,CAAC;QAC3E,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,gBAAgB,KAAK,UAAU,EAAE,CAAC;YACtD,MAAM,KAAK,GAAG,CAAC,CAAQ,EAAE,EAAE;gBACzB,MAAM,IAAI,GAAI,CAAmD,CAAC,WAAW,EAAE,GAAG,CAAC;gBACnF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC7C,CAAC,CAAC;YACF,GAAG,CAAC,gBAAgB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,mBAAmB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC,CAAC;QACtE,CAAC;QAED,8EAA8E;QAC9E,MAAM,CAAC,GAAG,OAAO,CAAC;QAClB,MAAM,QAAQ,GAAG,CAAC,CAAC,SAAS,CAAC;QAC7B,MAAM,WAAW,GAAG,CAAC,CAAC,YAAY,CAAC;QACnC,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QACjC,CAAC,CAAC,SAAS,GAAG,UAAU,GAAG,IAAsC;YAC/D,MAAM,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACrC,KAAK,EAAE,CAAC;YACR,OAAO,CAAC,CAAC;QACX,CAAC,CAAC;QACF,CAAC,CAAC,YAAY,GAAG,UAAU,GAAG,IAAyC;YACrE,MAAM,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;YACxC,KAAK,EAAE,CAAC;YACR,OAAO,CAAC,CAAC;QACX,CAAC,CAAC;QACF,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE;YACrB,CAAC,CAAC,SAAS,GAAG,QAAQ,CAAC;YACvB,CAAC,CAAC,YAAY,GAAG,WAAW,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QACjC,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC3C,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE;YACrB,MAAM,CAAC,mBAAmB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;YAC9C,MAAM,CAAC,mBAAmB,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,EAAE,GAAG,IAAI,EAAE;QACvB,IAAI,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC,IAAI,EAAE,CAAC;YAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YACvB,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC;YACf,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,IAAI;QACF,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO;YAAE,CAAC,EAAE,CAAC;QAClC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;CACF;AAED,SAAS,IAAI;IACX,IAAI,CAAC;QACH,OAAO,OAAO,QAAQ,KAAK,WAAW,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;IAClE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AACD,SAAS,QAAQ,CAAC,GAAW;IAC3B,IAAI,CAAC;QACH,OAAO,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,EAAE,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/features/journey/friction.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared friction primitives — rage-click clustering + dead-click detection. Used by F-JRN (and
+ * adoptable by the replay interaction recorder later). Kept dependency-free so it's trivially
+ * testable. Dead-click uses a LIGHTWEIGHT mutation-flag observer (a boolean "did anything change?",
+ * no serialization) so friction works with replay OFF.
+ */
+/** Rage = ≥`min` clicks clustered within `windowMs` and `radius` px. `push` returns the rage verdict. */
+export declare class RageDetector {
+    private readonly windowMs;
+    private readonly radius;
+    private readonly min;
+    private history;
+    constructor(windowMs?: number, radius?: number, min?: number);
+    push(x: number, y: number, t: number): boolean;
+}
+/** Fires a callback when a click had NO DOM change and NO navigation within `deadMs`. */
+export declare class DeadClickWatcher {
+    private readonly deadMs;
+    private changeVersion;
+    private observer;
+    private timers;
+    constructor(deadMs?: number);
+    observe(target: Node): void;
+    /** Resolve exactly once after the observation window. `true` means no DOM change + no navigation. */
+    onClick(onResult: (dead: boolean) => void): void;
+    disconnect(): void;
+}
+//# sourceMappingURL=friction.d.ts.map

package/dist/features/journey/friction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"friction.d.ts","sourceRoot":"","sources":["../../../src/features/journey/friction.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,yGAAyG;AACzG,qBAAa,YAAY;IAGrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJtB,OAAO,CAAC,OAAO,CAAkD;gBAE9C,QAAQ,SAAM,EACd,MAAM,SAAK,EACX,GAAG,SAAI;IAG1B,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;CAM/C;AAED,yFAAyF;AACzF,qBAAa,gBAAgB;IAKf,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJnC,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAiC;IACjD,OAAO,CAAC,MAAM,CAA4C;gBAE7B,MAAM,SAAM;IAEzC,OAAO,CAAC,MAAM,EAAE,IAAI,GAAG,IAAI;IAQ3B,qGAAqG;IACrG,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI;IAUhD,UAAU,IAAI,IAAI;CAMnB"}

package/dist/features/journey/friction.js

@@ -0,0 +1,64 @@
+/**
+ * Shared friction primitives — rage-click clustering + dead-click detection. Used by F-JRN (and
+ * adoptable by the replay interaction recorder later). Kept dependency-free so it's trivially
+ * testable. Dead-click uses a LIGHTWEIGHT mutation-flag observer (a boolean "did anything change?",
+ * no serialization) so friction works with replay OFF.
+ */
+/** Rage = ≥`min` clicks clustered within `windowMs` and `radius` px. `push` returns the rage verdict. */
+export class RageDetector {
+    constructor(windowMs = 800, radius = 30, min = 3) {
+        this.windowMs = windowMs;
+        this.radius = radius;
+        this.min = min;
+        this.history = [];
+    }
+    push(x, y, t) {
+        this.history = this.history.filter((c) => t - c.t < this.windowMs);
+        const near = this.history.filter((c) => Math.hypot(c.x - x, c.y - y) <= this.radius);
+        this.history.push({ x, y, t });
+        return near.length + 1 >= this.min;
+    }
+}
+/** Fires a callback when a click had NO DOM change and NO navigation within `deadMs`. */
+export class DeadClickWatcher {
+    constructor(deadMs = 700) {
+        this.deadMs = deadMs;
+        this.changeVersion = 0;
+        this.observer = null;
+        this.timers = new Set();
+    }
+    observe(target) {
+        if (typeof MutationObserver === 'undefined')
+            return;
+        this.observer = new MutationObserver(() => {
+            this.changeVersion++;
+        });
+        this.observer.observe(target, { subtree: true, childList: true, attributes: true, characterData: true });
+    }
+    /** Resolve exactly once after the observation window. `true` means no DOM change + no navigation. */
+    onClick(onResult) {
+        const version = this.changeVersion;
+        const startHref = href();
+        const timer = setTimeout(() => {
+            this.timers.delete(timer);
+            onResult(this.changeVersion === version && href() === startHref);
+        }, this.deadMs);
+        this.timers.add(timer);
+    }
+    disconnect() {
+        this.observer?.disconnect();
+        this.observer = null;
+        for (const t of this.timers)
+            clearTimeout(t);
+        this.timers.clear();
+    }
+}
+function href() {
+    try {
+        return typeof location !== 'undefined' ? location.href : '';
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=friction.js.map

package/dist/features/journey/friction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"friction.js","sourceRoot":"","sources":["../../../src/features/journey/friction.ts"],"names":[],"mappings":"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"}

package/dist/features/journey/positionContext.d.ts

@@ -0,0 +1,30 @@
+/**
+ * How an element is positioned relative to the page — the one fact that decides whether a click on
+ * it can be placed in document space at all.
+ *
+ * WHY CHECKING `fixed` WAS NOT ENOUGH. The previous rule walked ancestors for `position: fixed` and
+ * nothing else, so a `position: sticky` header read as ordinary content. Its clicks then went into
+ * the document-space lane, which must choose ONE page coordinate for them — and a sticky header is
+ * clicked at every scroll depth, so no single coordinate is right for more than a fraction of them.
+ * The heat sat where the header had been while the header was somewhere else.
+ *
+ * STICKY COUNTS EVEN WHEN NOT CURRENTLY STUCK. An element that will pin at some offset cannot be
+ * described by one document coordinate either, and the consumer positions it from its current rect,
+ * which is correct in both phases. Requiring it to be stuck at click time would make the answer
+ * depend on when the visitor happened to click.
+ *
+ * ANCESTORS, NOT JUST THE TARGET. The thing clicked is usually a link or an icon inside the
+ * positioned container, so the target's own `position` is almost always `static`.
+ *
+ * Nothing here names a tag, a class or a framework — it asks the browser what it computed.
+ *
+ * NUMERIC, AND IT SHIPS ON `fx`. The core bundle gate had 14 bytes of headroom; a `pc: 'sticky'`
+ * string field costs 60. Widening the value of the field that already exists is additive in the way
+ * that matters — every deployed reader tests `fx` for truthiness, and 2 is as truthy as 1, so an old
+ * backend treats a sticky click as element-owned, which is exactly the intended behaviour. A new
+ * reader can tell the two apart. No field changes meaning, and nothing has to be deployed in order.
+ */
+/** 0 = normal document flow · 1 = fixed ancestor · 2 = sticky ancestor. */
+export type PositionContext = 0 | 1 | 2;
+export declare function getPositionContext(el: Element): PositionContext;
+//# sourceMappingURL=positionContext.d.ts.map

package/dist/features/journey/positionContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positionContext.d.ts","sourceRoot":"","sources":["../../../src/features/journey/positionContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAgDxC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,OAAO,GAAG,eAAe,CAwC/D"}

package/dist/features/journey/positionContext.js

@@ -0,0 +1,116 @@
+/**
+ * How an element is positioned relative to the page — the one fact that decides whether a click on
+ * it can be placed in document space at all.
+ *
+ * WHY CHECKING `fixed` WAS NOT ENOUGH. The previous rule walked ancestors for `position: fixed` and
+ * nothing else, so a `position: sticky` header read as ordinary content. Its clicks then went into
+ * the document-space lane, which must choose ONE page coordinate for them — and a sticky header is
+ * clicked at every scroll depth, so no single coordinate is right for more than a fraction of them.
+ * The heat sat where the header had been while the header was somewhere else.
+ *
+ * STICKY COUNTS EVEN WHEN NOT CURRENTLY STUCK. An element that will pin at some offset cannot be
+ * described by one document coordinate either, and the consumer positions it from its current rect,
+ * which is correct in both phases. Requiring it to be stuck at click time would make the answer
+ * depend on when the visitor happened to click.
+ *
+ * ANCESTORS, NOT JUST THE TARGET. The thing clicked is usually a link or an icon inside the
+ * positioned container, so the target's own `position` is almost always `static`.
+ *
+ * Nothing here names a tag, a class or a framework — it asks the browser what it computed.
+ *
+ * NUMERIC, AND IT SHIPS ON `fx`. The core bundle gate had 14 bytes of headroom; a `pc: 'sticky'`
+ * string field costs 60. Widening the value of the field that already exists is additive in the way
+ * that matters — every deployed reader tests `fx` for truthiness, and 2 is as truthy as 1, so an old
+ * backend treats a sticky click as element-owned, which is exactly the intended behaviour. A new
+ * reader can tell the two apart. No field changes meaning, and nothing has to be deployed in order.
+ */
+/**
+ * `fixed` wins over `sticky` when both appear: the nearest fixed ancestor is what actually detaches
+ * the subtree from the document, and a sticky element inside a fixed one travels with the fixed one.
+ */
+/**
+ * `position: fixed` IS NOT ALWAYS FIXED, and believing it was is worth up to a full page of error.
+ *
+ * An ancestor with a transform, a filter, a perspective, `will-change` naming any of those, or
+ * `contain: paint/layout/strict/content` establishes a CONTAINING BLOCK for fixed descendants. A
+ * fixed element inside one is positioned against that ancestor and scrolls with the page like
+ * ordinary content — the browser says `position: fixed` and means something else.
+ *
+ * MEASURED, by `heat:css`, one target per construct on a page whose reconstruction is identical to
+ * the capture, so nothing else could explain it:
+ *
+ *     transform      the click landed  524 px from the control
+ *     filter                          1198 px
+ *     will-change                     1515 px
+ *     contain                         1833 px
+ *
+ * The error IS the scroll depth, every time, and the mechanism is exact: this function said 1, so
+ * `resolvePagePoint` dropped the scroll offset and placed the click at the top of the document
+ * while the control was most of a page below. A wrapper as ordinary as `will-change: transform` on
+ * a scroll container — or `transform: translateZ(0)` for GPU promotion, which is everywhere — is
+ * enough to trigger it.
+ *
+ * One extra `getComputedStyle` read per ancestor ABOVE the fixed one, and only once a fixed
+ * ancestor has been seen, so the common path (no fixed ancestor at all) is unchanged.
+ */
+/**
+ * A property is SET when it has a real value that is not the initial one.
+ *
+ * The empty string matters: not every engine reports a computed value for every property, and
+ * jsdom returns '' for most of these. Testing `!== 'none'` therefore said "transformed" about every
+ * element in the world and turned every fixed ancestor into flow — six tests caught it immediately,
+ * but a browser that reported '' would have done the same thing silently in production.
+ */
+const set = (v) => !!v && v !== 'none';
+const establishesContainingBlock = (s) => set(s.transform) ||
+    set(s.filter) ||
+    set(s.perspective) ||
+    /transform|filter|perspective/.test(s.willChange || '') ||
+    /paint|layout|strict|content/.test(s.contain || '');
+export function getPositionContext(el) {
+    // No `typeof window` guard: this runs only inside DOM event handlers, which never fire server-side.
+    let sticky = 0;
+    let fixed = false;
+    let scrollport = false;
+    for (let n = el; n; n = n.parentElement) {
+        const s = getComputedStyle(n);
+        if (fixed) {
+            /**
+             * Anything above the fixed element that captures it means it is NOT viewport-anchored. Report
+             * FLOW rather than fixed: its clicks belong in document space, where `y + scrollY` is right.
+             * Returning 0 rather than falling back to `sticky` is deliberate — a sticky ancestor above a
+             * containing block describes a different element's behaviour, not this one's.
+             */
+            if (establishesContainingBlock(s))
+                return 0;
+        }
+        else if (s.position === 'fixed') {
+            fixed = true;
+        }
+        else if (s.position === 'sticky') {
+            sticky = 2;
+            scrollport = true;
+        }
+        else if (scrollport && /auto|scroll|hidden|clip/.test(s.overflowY || '')) {
+            /**
+             * A STICKY ELEMENT THAT CANNOT STICK IS ORDINARY CONTENT.
+             *
+             * Sticky positions against the nearest scrollport, and `overflow: hidden` creates one. If that
+             * scrollport has nothing to scroll, the element never moves from its natural place and its
+             * document coordinate is exactly right — so calling it viewport-anchored throws away the one
+             * correct answer. `heat:css` measured this at 2042 px, the full scroll depth, because the
+             * click was placed at the top of the document.
+             *
+             * An `overflow: hidden` wrapper silently disabling a sticky child is one of the best-known CSS
+             * accidents, so this is not an exotic shape. Only the FIRST scrollport is consulted: that is
+             * the one sticky answers to, and a scrollable one leaves the verdict at 2, which is correct
+             * because such an element really does move independently of the document.
+             */
+            scrollport = false;
+            if (n.scrollHeight <= n.clientHeight)
+                sticky = 0;
+        }
+    }
+    return fixed ? 1 : sticky;
+}
+//# sourceMappingURL=positionContext.js.map

package/dist/features/journey/positionContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positionContext.js","sourceRoot":"","sources":["../../../src/features/journey/positionContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAKH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;;;;;;;GAOG;AACH,MAAM,GAAG,GAAG,CAAC,CAAS,EAAW,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,MAAM,CAAC;AAExD,MAAM,0BAA0B,GAAG,CAAC,CAAsB,EAAW,EAAE,CACrE,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC;IAChB,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;IACb,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;IAClB,8BAA8B,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,IAAI,EAAE,CAAC;IACvD,6BAA6B,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC;AAEtD,MAAM,UAAU,kBAAkB,CAAC,EAAW;IAC5C,oGAAoG;IACpG,IAAI,MAAM,GAAoB,CAAC,CAAC;IAChC,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,KAAK,IAAI,CAAC,GAAmB,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,aAAa,EAAE,CAAC;QACxD,MAAM,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;QAC9B,IAAI,KAAK,EAAE,CAAC;YACV;;;;;eAKG;YACH,IAAI,0BAA0B,CAAC,CAAC,CAAC;gBAAE,OAAO,CAAC,CAAC;QAC9C,CAAC;aAAM,IAAI,CAAC,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;YAClC,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;aAAM,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACnC,MAAM,GAAG,CAAC,CAAC;YACX,UAAU,GAAG,IAAI,CAAC;QACpB,CAAC;aAAM,IAAI,UAAU,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,CAAC;YAC3E;;;;;;;;;;;;;eAaG;YACH,UAAU,GAAG,KAAK,CAAC;YACnB,IAAI,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,YAAY;gBAAE,MAAM,GAAG,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AAC5B,CAAC"}

package/dist/features/journey/uiState.d.ts

@@ -0,0 +1,44 @@
+/**
+ * UI STATE AT INTERACTION TIME — which visual surface the visitor was actually looking at.
+ *
+ * A page is not just `/products`. It is `/products` with the cart drawer shut, or with it open, or
+ * with the reviews tab selected. Those are different interaction surfaces, and a click on one must
+ * never be counted on another: heat from the open drawer painted over the closed layout is a picture
+ * of something that never existed.
+ *
+ * WHAT WAS WRONG WITH THE PREVIOUS SHAPE. State was captured as an opaque set of the things that
+ * happened to be OPEN — `menu|dialog`, sorted and joined. Two consequences:
+ *
+ *   1. `sidebar = closed` was not representable. Absence meant "nothing open", which conflates a shut
+ *      sidebar with a page that has no sidebar. But the click that OPENS a drawer belongs to the
+ *      closed state — that is what the visitor saw when they reached for it — so the closed value has
+ *      to exist to receive it.
+ *   2. It could not be queried by dimension. Asking for `sidebar=open` meant matching the whole
+ *      signature, so every unrelated dimension had to match too and the buckets fragmented
+ *      combinatorially.
+ *
+ * THE SHAPE NOW: `name:value` pairs, sorted, joined with `;`. Still ONE short string on the wire — no
+ * new field — but the backend can split it and match one dimension without constraining the others.
+ *
+ * DELIBERATELY NARROW, because every byte here is eager. Only `aria-expanded` (read in BOTH states,
+ * which is what makes "closed" a value rather than an absence) and `dialog` (likewise). No
+ * `aria-selected`, no `aria-current`, no `details` — those were measured at ~90 B of bundle for
+ * dimensions the host can declare explicitly for free. No class-name guessing at any price: `.is-open`
+ * is right on some sites and silently wrong on others, and a wrong state key partitions clicks into
+ * buckets that correspond to nothing.
+ *
+ * Anything the platform does not express is `setUiState`'s job, and an explicit dimension WINS for the
+ * same name — a heuristic that silently overrode a declaration would make the API pointless.
+ */
+/** Declare a UI state dimension the DOM does not express. */
+export declare function setUiState(name: string, value: string): void;
+/**
+ * Stop reporting a dimension — or, with no name, every declared dimension.
+ *
+ * Later interactions carry no value for it, which is not the same as carrying a value. Clearing all is
+ * what a single-page app wants on route change: declarations from the previous screen would otherwise
+ * follow the visitor onto a surface where they mean nothing.
+ */
+export declare function clearUiState(name?: string): void;
+export declare function uiStateSignature(): string | undefined;
+//# sourceMappingURL=uiState.d.ts.map

package/dist/features/journey/uiState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uiState.d.ts","sourceRoot":"","sources":["../../../src/features/journey/uiState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAaH,6DAA6D;AAC7D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAI5D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAGhD;AAuDD,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAwCrD"}