@scalebun-release/web 2.2.2

package/dist/features/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * features/ — pluggable capture features (each implements IFeature from @scalebun/sdk-contracts
+ * and registers with the FeatureRegistry). Mirrors RN react-native/src/features.
+ *
+ * 🚧 NOT IMPLEMENTED YET (intentionally — scaffold only). Planned folders, mapped to mobile:
+ *
+ *   errors/      JS errors: window.onerror + unhandledrejection + manual capture   (RN: crash/)
+ *   network/     fetch + XHR + sendBeacon interceptors, denylist-by-default        (RN: network/)
+ *   webVitals/   LCP / INP / CLS / FCP / TTFB — in the core, no web-vitals dep      (RN: performance/)
+ *   performance/ custom traces, resource timing, LoAF attribution                  (RN: performance/)
+ *   replay/      DOM snapshot + mutations (renderer:'dom'), capture-on-signal       (RN: replay/)
+ *   session/     SessionManager + boundary (timeout / pagehide)                     (RN: session/)
+ *   journey/     route/page tracking, click / rage-click / dead-click              (RN: journey/)
+ *   navigation/  Navigation API + history fallback (SPA route names)               (RN: navigation/)
+ *   bugreport/   embeddable widget + auto-context report                           (RN: bugreport/)
+ *   ratings/     in-app rating / survey response                                   (RN: rating)
+ *
+ * See ../../../../WEB-SDK-PLAN.md §5 (parity) and §7 (sequenced work).
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/features/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/features/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC"}

package/dist/features/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/features/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/features/index.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,87 @@
+export interface InteractionTrackerOptions {
+    deadMs?: number;
+    rageWindowMs?: number;
+    rageRadius?: number;
+    rageMin?: number;
+    /** Mask the label text (`privacy.maskEventText`). Default false — the real label is sent. */
+    maskText?: boolean;
+}
+export interface InteractionEmission {
+    interactionId: string;
+    timestamp: number;
+    /**
+     * THE PAGE THE CLICK HAPPENED ON — pinned when it happened, not when it is emitted.
+     *
+     * A USER_ACTION is emitted from `finish()`, which runs after the dead-click observation window
+     * closes. The caller then filled `screenName` from `location.pathname` AT THAT MOMENT, so any
+     * click that navigates — every CTA, every nav link, every "sign in" button — was filed against
+     * the page it navigated TO, where that control does not exist.
+     *
+     * Measured on production (joint web, 3 days, 16,602 clicks with a witness frame): 9.3% of clicks
+     * disagreed with the route of the frame they were captured against, after normalising the query
+     * string away. The disagreeing clicks sit CLOSER to their frame than the agreeing ones (median
+     * 4.9 s vs 9.2 s), which is the signature of a route read after a navigation rather than of a
+     * stale frame. `/` -> `/sign-in`, `/` -> `/doctors` and `/patient/main` -> `/patient/booking`
+     * were the three largest pairs.
+     *
+     * The timestamp beside it has always been the pointerdown time, and `ui` has always been read at
+     * pointerdown too, for exactly this reason: what was on screen when the visitor reached for the
+     * control. The route was the one piece of that moment still being read at the end. Now it is not.
+     *
+     * Optional, because a caller that does not pin one keeps the old behaviour rather than losing the
+     * field entirely.
+     */
+    route?: string;
+}
+type EmitAction = (name: string, data: Record<string, unknown>, label?: string, interaction?: InteractionEmission) => void;
+export declare class InteractionTracker {
+    private readonly emit;
+    /** Raise a capture signal ('rage'|'dead') onto the bus — arms friction-triggered features
+     *  (replay capture-on-signal, struggle-triggered surveys/in-app). Optional (tests omit it). */
+    private readonly signal?;
+    private readonly rage;
+    private readonly dead;
+    private readonly maskText;
+    private onClickFn?;
+    private onPointerDownFn?;
+    private onPageHideFn?;
+    private pointerDown?;
+    private pending;
+    constructor(emit: EmitAction, opts?: InteractionTrackerOptions, 
+    /** Raise a capture signal ('rage'|'dead') onto the bus — arms friction-triggered features
+     *  (replay capture-on-signal, struggle-triggered surveys/in-app). Optional (tests omit it). */
+    signal?: ((reason: string) => void) | undefined);
+    start(): void;
+    stop(): void;
+    /**
+     * Emit the one row for this interaction.
+     *
+     * `dead` is THREE-VALUED here, and that is the point. `true` and `false` are verdicts the watcher
+     * actually reached; `undefined` means the page went away before the observation window closed, so
+     * nobody looked. Writing `dead: false` in that case asserts a measurement never taken — "this click
+     * DID cause a change" — and a dead-click rate computed from it is wrong in exactly the situation
+     * where dead clicks matter most: the visitor left immediately after clicking.
+     *
+     * So the key is omitted rather than defaulted, the same rule the rest of this pipeline follows:
+     * absent means unknown, never zero. `deadUnknown` records WHY it is absent, so a consumer can tell
+     * "not dead" from "we never found out".
+     */
+    private finish;
+    /**
+     * Flush every interaction still awaiting its dead-click verdict.
+     *
+     * Runs on `pagehide` and on `stop()`. Without it a click followed immediately by a navigation is
+     * never emitted at all — the whole row is lost, which is strictly worse than an unknown flag. The
+     * verdict is passed as `undefined` because none was reached; see finish().
+     */
+    private flushPending;
+}
+/**
+ * A human-ish label: tag + short text, e.g. `button: Buy now`.
+ *
+ * `maskText` (from `privacy.maskEventText`) replaces every non-whitespace character with `*`, keeping
+ * the word shape. Exported so the unit tests can drive both branches directly.
+ */
+export declare function describe(el: Element, maskText?: boolean): string;
+export {};
+//# sourceMappingURL=InteractionTracker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionTracker.d.ts","sourceRoot":"","sources":["../../../src/features/journey/InteractionTracker.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,UAAU,GAAG,CAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,KAAK,CAAC,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,mBAAmB,KAC9B,IAAI,CAAC;AAUV,qBAAa,kBAAkB;IAW3B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAErB;mGAC+F;IAC/F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAd1B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAe;IACpC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAmB;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAU;IACnC,OAAO,CAAC,SAAS,CAAC,CAAqB;IACvC,OAAO,CAAC,eAAe,CAAC,CAAqB;IAC7C,OAAO,CAAC,YAAY,CAAC,CAAa;IAClC,OAAO,CAAC,WAAW,CAAC,CAAgB;IACpC,OAAO,CAAC,OAAO,CAAoC;gBAGhC,IAAI,EAAE,UAAU,EACjC,IAAI,GAAE,yBAA8B;IACpC;mGAC+F;IAC9E,MAAM,CAAC,GAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,aAAA;IAOpD,KAAK,IAAI,IAAI;IAsCb,IAAI,IAAI,IAAI;IAaZ;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,MAAM;IAad;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;CAGrB;AAuSD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,OAAO,EAAE,QAAQ,UAAQ,GAAG,MAAM,CAK9D"}

package/dist/features/journey/InteractionTracker.js

@@ -0,0 +1,466 @@
+/**
+ * Clicks → USER_ACTION analytics events, with rage + dead-click flags (the friction signals) and a
+ * target label/selector. Always-on + cheap; does NOT depend on replay.
+ *
+ * LABEL TEXT IS NO LONGER MASKED BY DEFAULT (`privacy.maskEventText`, default false). It used to be
+ * unconditional — every non-whitespace character replaced with `*` — which is why the Events explorer
+ * rendered `button: *** ***`. Because rows there group by label, masking preserved the SHAPE of the
+ * text and destroyed its identity: two different buttons whose text happened to be the same length
+ * merged into a single row, so per-element click analytics could not exist. The selector was always
+ * unmasked, so this never was the SDK's privacy boundary anyway.
+ */
+import { RageDetector, DeadClickWatcher } from './friction.js';
+import { getPositionContext } from './positionContext.js';
+import { uiStateSignature } from './uiState.js';
+import { getReplayCoord, uuid } from '../../core/index.js';
+export class InteractionTracker {
+    constructor(emit, opts = {}, 
+    /** Raise a capture signal ('rage'|'dead') onto the bus — arms friction-triggered features
+     *  (replay capture-on-signal, struggle-triggered surveys/in-app). Optional (tests omit it). */
+    signal) {
+        this.emit = emit;
+        this.signal = signal;
+        this.pending = new Map();
+        this.rage = new RageDetector(opts.rageWindowMs ?? 800, opts.rageRadius ?? 30, opts.rageMin ?? 3);
+        this.dead = new DeadClickWatcher(opts.deadMs ?? 700);
+        this.maskText = opts.maskText ?? false;
+    }
+    start() {
+        if (typeof document === 'undefined')
+            return;
+        this.dead.observe(document);
+        this.onPointerDownFn = (e) => {
+            const pe = e;
+            if (pe.isPrimary === false || (typeof pe.button === 'number' && pe.button !== 0))
+                return;
+            const target = eventTarget(e);
+            if (!target)
+                return;
+            this.pointerDown = capture(target, pe, Date.now(), this.maskText);
+        };
+        this.onClickFn = (e) => {
+            const me = e;
+            const target = eventTarget(e);
+            if (!target)
+                return;
+            const down = this.pointerDown;
+            this.pointerDown = undefined;
+            // A real pointer click reuses the evidence captured when the finger/button landed. Keyboard
+            // and programmatic clicks have no pointerdown and are measured honestly at click time.
+            const captured = me.detail !== 0 && down && down.target === target && Date.now() - down.timestamp < 5000
+                ? down
+                : capture(target, me, Date.now(), this.maskText);
+            const rage = this.rage.push(captured.x, captured.y, captured.timestamp);
+            if (rage)
+                captured.data.rage = true;
+            if (rage)
+                this.signal?.('rage'); // RageDetector coalesces → one signal per cluster
+            this.pending.set(captured.interactionId, captured);
+            this.dead.onClick((dead) => {
+                this.finish(captured.interactionId, dead);
+                if (dead)
+                    this.signal?.('dead');
+            });
+        };
+        this.onPageHideFn = () => this.flushPending();
+        document.addEventListener('pointerdown', this.onPointerDownFn, true);
+        document.addEventListener('click', this.onClickFn, true);
+        if (typeof window !== 'undefined')
+            window.addEventListener('pagehide', this.onPageHideFn, true);
+    }
+    stop() {
+        this.flushPending();
+        this.dead.disconnect();
+        if (typeof document !== 'undefined') {
+            if (this.onPointerDownFn)
+                document.removeEventListener('pointerdown', this.onPointerDownFn, true);
+            if (this.onClickFn)
+                document.removeEventListener('click', this.onClickFn, true);
+        }
+        if (this.onPageHideFn && typeof window !== 'undefined') {
+            window.removeEventListener('pagehide', this.onPageHideFn, true);
+        }
+        this.pointerDown = undefined;
+    }
+    /**
+     * Emit the one row for this interaction.
+     *
+     * `dead` is THREE-VALUED here, and that is the point. `true` and `false` are verdicts the watcher
+     * actually reached; `undefined` means the page went away before the observation window closed, so
+     * nobody looked. Writing `dead: false` in that case asserts a measurement never taken — "this click
+     * DID cause a change" — and a dead-click rate computed from it is wrong in exactly the situation
+     * where dead clicks matter most: the visitor left immediately after clicking.
+     *
+     * So the key is omitted rather than defaulted, the same rule the rest of this pipeline follows:
+     * absent means unknown, never zero. `deadUnknown` records WHY it is absent, so a consumer can tell
+     * "not dead" from "we never found out".
+     */
+    finish(interactionId, dead) {
+        const captured = this.pending.get(interactionId);
+        if (!captured)
+            return;
+        this.pending.delete(interactionId);
+        if (dead === true)
+            captured.data.dead = true;
+        else if (dead === undefined)
+            captured.data.deadUnknown = true;
+        this.emit('USER_ACTION', captured.data, captured.label, {
+            interactionId,
+            timestamp: captured.timestamp,
+            route: captured.route,
+        });
+    }
+    /**
+     * Flush every interaction still awaiting its dead-click verdict.
+     *
+     * Runs on `pagehide` and on `stop()`. Without it a click followed immediately by a navigation is
+     * never emitted at all — the whole row is lost, which is strictly worse than an unknown flag. The
+     * verdict is passed as `undefined` because none was reached; see finish().
+     */
+    flushPending() {
+        for (const interactionId of [...this.pending.keys()])
+            this.finish(interactionId, undefined);
+    }
+}
+function eventTarget(e) {
+    // SHADOW DOM — see the note below. `e.target` is retargeted to the host, so the composed
+    // path is what identifies the control. Our own surfaces stay reported as their host, which
+    // is what keeps the query-side exclusion matching them.
+    let target = e.target;
+    if (!target || !target.tagName)
+        return null;
+    if (!target.hasAttribute('data-scalebun')) {
+        const deep = e.composedPath?.()[0];
+        if (deep && deep.tagName)
+            target = deep;
+    }
+    return target;
+}
+function capture(target, pointerEvent, timestamp, maskText) {
+    const ui = uiStateSignature();
+    const data = {
+        action: 'click',
+        ...pointer(pointerEvent),
+        selector: selectorOf(target),
+        ...anchor(target, maskText),
+        state_status: ui ? 'captured_nonempty' : 'captured_empty',
+    };
+    if (ui)
+        data.ui = ui;
+    const replay = getReplayCoord();
+    if (replay)
+        data.replayCoord = replay;
+    return {
+        target,
+        x: pointerEvent.clientX,
+        y: pointerEvent.clientY,
+        data,
+        label: describe(target, maskText),
+        interactionId: `ixw-${uuid()}`,
+        timestamp,
+        /* Read HERE, in the same breath as the coordinates and the ui state. See InteractionEmission. */
+        route: currentPath(),
+    };
+}
+/**
+ * The element the visitor actually clicked, not the wrapper the browser reports.
+ *
+ * `event.target` is RETARGETED at a shadow boundary: a click on a button inside a web component is
+ * reported as a click on the component's host, so every control inside it collapses onto one
+ * element and neither the selector nor the path describes what was hit. `composedPath()[0]` is the
+ * real node, and both of the SDK's other capture lanes already use it — the replay engine says so
+ * outright ("composedPath()[0] beats e.target, which is the host"). This lane was the one that
+ * never got the fix, and it is the lane heatmaps read.
+ *
+ * OUR OWN WIDGETS ARE DELIBERATELY NOT UNWRAPPED. Every ScaleBun surface — in-app, inbox, survey,
+ * coachmark, soft-ask, bug report — is mounted in a shadow root too, and the query layer keeps
+ * those clicks out of customer heatmaps by matching the HOST's selector. Resolving through them
+ * would produce an inner control the filter does not recognise, so clicks on ScaleBun's own UI
+ * would start being reported as clicks on the customer's page. Reporting the host for our surfaces
+ * is therefore not a limitation, it is what keeps the existing exclusion working — and it keeps
+ * that decision in one place rather than splitting it across two repos.
+ *
+ * Falls back to `event.target` whenever the composed path is unavailable or its first entry is not
+ * an element (text nodes, the document, a closed root's boundary), so nothing is lost when the
+ * answer cannot be improved.
+ */
+/* resolution happens inline in the click handler — see the note above. */
+/** Click position + viewport + scroll + document height, so the dashboard can place clicks in
+ *  viewport-% or DOCUMENT space across different screen sizes. `x`/`y` are viewport-relative (clientX/Y).
+ *
+ *  `dh` is the whole document's height. Without it a click's page position is unrecoverable — `y + sy`
+ *  is a pixel offset with no denominator — so heatmaps of a scrollable page had to fold the entire
+ *  document onto one screenful, stacking below-fold clicks on top of the hero. Read unguarded because
+ *  `pointer` only runs from the click handler, which `start()` never installs without a document; one
+ *  layout read per click, next to the target rect the handler already measures. Width is deliberately
+ *  NOT sent: horizontal scrolling is vanishingly rare, and the viewport width the dashboard already
+ *  has is the right horizontal denominator for a responsive layout. */
+function pointer(me) {
+    const w = typeof window !== 'undefined' ? window : undefined;
+    return {
+        x: me.clientX,
+        y: me.clientY,
+        vw: w?.innerWidth ?? 0,
+        vh: w?.innerHeight ?? 0,
+        sx: w ? Math.round(w.scrollX) : 0,
+        sy: w ? Math.round(w.scrollY) : 0,
+        dh: document.documentElement.scrollHeight,
+        // H5 — devicePixelRatio: sharper backdrops + a device-density bucketing dimension for heatmaps.
+        dpr: w?.devicePixelRatio ?? 1,
+    };
+}
+/**
+ * A CONTRADICTION SIGNAL, NOT A LOCATOR — one independent fact about what was clicked.
+ *
+ * `path` resolves uniquely on real markup (measured 30/30 on the reported site) but is FRAGILE: one
+ * inserted sibling shifts an `nth-of-type` segment onto a different control, and the reader has no
+ * way to notice. This field exists so it can notice. When the element a stored path resolves to
+ * contradicts this, the reader refuses to anchor.
+ *
+ * IT MAY ONLY EVER REFUSE. Agreement is not evidence of identity: a duplicate sibling carrying the
+ * same href satisfies it exactly, which is why promoting on agreement was measured and rejected —
+ * it raised silent mis-anchors from 12 to 14 across 156 adversarial trials while looking like an
+ * improvement. Refusal-only took them from 12 to 2 and cannot, by construction, add an anchor.
+ *
+ * PRIVACY. Four signals, in this order, and nothing else:
+ *   · href PATHNAME — query string and fragment stripped, so tokens, emails and ids never travel.
+ *   · aria-label — author-written UI wording, capped at 32 chars and rejected outright if it carries
+ *     an address or a long digit run, which is what a personalised label looks like.
+ *   · the element’s own VISIBLE TEXT, under the same cap and the same two refusals, and only when
+ *     `privacy.maskEventText` is off. See the note on the fallback for why it had to be added.
+ *   · type — a build-time constant on form controls.
+ * Deliberately excluded: input values, full URLs, class lists.
+ *
+ * THIS PARAGRAPH SAID THE OPPOSITE FOR ONE RELEASE. 2.2.0 added the text fallback and left the line
+ * above reading "nothing derived from user text / Deliberately excluded: visible text" — a privacy
+ * claim the code beneath it had stopped honouring. It is the paragraph an auditor reads and the one
+ * quoted when this field comes up in due diligence, so correcting it is part of the change rather
+ * than documentation to catch up later.
+ *
+ * One optional field, absent when nothing safe is available, so the common case adds no bytes and an
+ * old reader that ignores it behaves exactly as before.
+ */
+function constraintOf(el, maskText) {
+    // Same normalisation as `stripQuery` in core/breadcrumbs and performance/resources — one regex,
+    // and it drops the fragment as well, so `#anchor` links reduce to their path.
+    const h = (el.getAttribute('href') || '').replace(/[?#].*$/, '');
+    // No `javascript:` guard: this is a comparison token, not a URL to follow, so an odd scheme is
+    // harmless and the check cost more bytes than the case is worth.
+    if (h)
+        return 'h' + h;
+    /**
+     * TEXT IS THE FALLBACK, AND FOR MOST CONTROLS IT IS THE ONLY IDENTITY THERE IS.
+     *
+     * With href, aria-label and type all absent this returned undefined — and a plain
+     * `<button>Book now</button>` is exactly that shape. Without a constraint the viewer cannot
+     * witness uniqueness, so the click cannot anchor and is drawn at a coordinate instead of on the
+     * control. Measured on the live application: 54% of clicks carry no constraint at all, and the
+     * page's main call to action is one of them, which is the reported "the CTA has no heat on it".
+     *
+     * `heat:groundtruth` is what says this is the missing piece rather than the trust rule: it
+     * reports that id-less targets DO classify as TRUSTED once uniqueness is witnessed, and that a
+     * sibling or duplicate inserted beside them is caught every time — 0 silently wrong across every
+     * adversarial pass. So the evidence machinery works; it was simply being handed nothing to work
+     * with for most elements.
+     *
+     * SHARES THE ARIA GUARD DELIBERATELY, not just to save bytes. A label and a caption carry the
+     * same privacy risk — a name, an email, an order number — and the same rule handles both: short,
+     * no address, no long digit run. One rule is also one thing to audit, and this is a field that
+     * leaves the device.
+     *
+     * `textContent` rather than innerText: it does not force layout, it is what the reconstruction
+     * will compare against, and it is stable when the control is off screen.
+     */
+    /**
+     * MASKING APPLIES HERE TOO, AND FOR ONE RELEASE IT DID NOT.
+     *
+     * `privacy.maskEventText` already stars out `label` (see describe), so a tenant who turns it on
+     * has every visible string masked on the way out — except this one, which 2.2.0 quietly began
+     * sending in clear. Same text, same event, one field over. A masking switch that misses a field is
+     * worse than no switch, because it is relied on.
+     *
+     * aria-label stays on BOTH sides of the branch. It is author-written wording, it shipped in this
+     * field before the text fallback existed, and it is what the paragraph above has always promised;
+     * withholding it under masking would change behaviour nobody asked to change. Only the fallback —
+     * the part that reads what the USER sees — is withheld.
+     *
+     * The consequence is deliberate: with masking on, a control whose only identity is its text has no
+     * constraint, cannot witness uniqueness, and is drawn at a coordinate. Less anchoring is the right
+     * trade against sending text a tenant asked us not to send.
+     */
+    const a = (el.getAttribute('aria-label') || (maskText ? '' : el.textContent) || '').trim();
+    // A long digit run or an address is what a personalised label looks like — refuse those.
+    if (a && a.length < 33 && !/@|\d{4,}/.test(a))
+        return 'a' + a;
+    const t = el.getAttribute('type');
+    return t ? 'y' + t : undefined;
+}
+/** H7 — element bounding rect (for responsive re-anchoring) + opt-in component name (for component heatmaps). */
+function anchor(el, maskText) {
+    const r = el.getBoundingClientRect();
+    const out = { ex: r.x | 0, ey: r.y | 0, ew: r.width | 0, eh: r.height | 0 };
+    /**
+     * VIEWPORT ANCHORING — `fx` is now 1 for fixed and 2 for STICKY.
+     *
+     * Additive by widening the value rather than by adding a field. 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 — exactly the intended behaviour — while a new one can tell them apart. Nothing
+     * changes meaning and no deploy ordering is required.
+     *
+     * A separate `pc: 'sticky'` string was written first and reverted: it cost 60 bytes against 14
+     * bytes of core headroom. See positionContext.ts.
+     *
+     * STICKY IS WHY THIS CHANGED AT ALL. The old check looked for `position: fixed` and nothing else,
+     * so a sticky header read as ordinary content and its clicks went to the document-space lane —
+     * which must choose one page coordinate for a control clicked at every scroll depth.
+     */
+    const pc = getPositionContext(el);
+    // Emitted only when there is something to say, so the common case still adds no bytes.
+    if (pc)
+        out.fx = pc;
+    out.path = structuralPath(el);
+    const cx = constraintOf(el, maskText);
+    if (cx)
+        out.cx = cx;
+    const comp = el.closest('[data-scalebun-component]')?.getAttribute('data-scalebun-component');
+    if (comp)
+        out.component = comp;
+    return out;
+}
+/**
+ * True when this click landed on a VIEWPORT-anchored element — one that does not move as the page
+ * scrolls, because it or an ancestor computes to `position: fixed`.
+ *
+ * WHY THE DASHBOARD NEEDS THIS. A click's page position is derived as `y + sy`: viewport coordinate
+ * plus scroll offset. For a fixed element that arithmetic is meaningless — it never moved, so adding
+ * how far the visitor happened to have scrolled scatters one physical button down the whole document.
+ * Measured on real data before this field existed: a single fixed host produced clicks at 22 distinct
+ * page depths between 0.5% and 50.8%, which is 10% of all placeable clicks laid down as a false
+ * vertical streak. A structured artefact like that reads as a finding; noise does not.
+ *
+ * It was worked around by excluding one selector we own by name. That only ever covered OUR widget —
+ * the customer's sticky header, cookie banner and third-party chat have the identical defect and
+ * cannot be recognised from a selector. This field is the general fix, and it is the ELEMENT that
+ * knows: only capture can answer it, which is why it belongs here and not in the query.
+ *
+ * ONLY `fixed`, DELIBERATELY NOT `sticky`. A sticky element behaves like a fixed one *while stuck*
+ * and like normal content otherwise, and which of the two it is at click time cannot be decided from
+ * the element alone without reconstructing its natural flow position. Reporting a guess would put
+ * clicks in a confidently wrong place, which is the failure this field exists to remove. Sticky
+ * therefore keeps today's behaviour until it can be answered rather than estimated.
+ *
+ * Emitted only when TRUE (`fx: 1`), so the common case adds no bytes to the payload.
+ *
+ * Cost: `getComputedStyle` per ancestor, on click only. Layout is already flushed by the
+ * `getBoundingClientRect` above, so these reads hit a clean style tree rather than forcing a
+ * recalculation. Uncapped depth on purpose — a cap would silently misreport exactly the deeply
+ * nested content inside a fixed modal that most needs this to be right.
+ */
+/**
+ * A STRUCTURAL path to the clicked element — `main>div:nth-of-type(2)>button`.
+ *
+ * WHY, given `selector` already exists. `selector` is the element's own tag and classes, which turns
+ * out to identify almost nothing: measured across 849 real clicks, the single commonest value is a
+ * bare `div` (159 of them), followed by Tailwind utility soups like `div.flex.flex-col`. None of
+ * those distinguish one element from thousands of others, so anything built on them — anchoring a
+ * click to the control it hit, following a control across a redesign — is no more reliable than raw
+ * coordinates while LOOKING far more precise. That combination is the worst of the two.
+ *
+ * A path is stable where classes are not: utility classes change whenever the design does, but a
+ * button's position in the document structure usually survives a restyle.
+ *
+ * ADDED ALONGSIDE `selector`, NOT REPLACING IT. The component heatmap aggregates on `selector`
+ * today; changing its meaning underneath would silently re-bucket every existing aggregate against
+ * history captured under the old rule.
+ *
+ * Captured now although nothing consumes it yet, which is a deliberate exception to not shipping
+ * unused fields: a path cannot be reconstructed after the fact from a stored click, so the data has
+ * to start accumulating before the feature that needs it can be built at all. The alternative is
+ * building it later and having no history to run it against.
+ *
+ * An `id` ENDS the walk — an id is unique in the document, so everything above it is noise, and
+ * stopping keeps the common case short. Depth is capped for the same reason: bytes on every click
+ * are real, and the segments nearest the element carry nearly all of the identifying power.
+ *
+ * `nth-of-type` is emitted only when a parent holds more than one child of that tag, so a page whose
+ * structure is already unambiguous pays nothing for it.
+ */
+function structuralPath(el) {
+    const parts = [];
+    let n = el;
+    for (let depth = 0; n && depth < 6; depth++) {
+        const tag = n.tagName.toLowerCase();
+        if (tag === 'html' || tag === 'body')
+            break;
+        if (n.id) {
+            parts.unshift(`${tag}#${n.id}`);
+            break;
+        }
+        const up = n.parentElement;
+        if (up) {
+            let index = 0;
+            let total = 0;
+            const kids = up.children;
+            const self = n;
+            for (let i = 0; i < kids.length; i++) {
+                const kid = kids[i];
+                if (!kid || kid.tagName !== self.tagName)
+                    continue;
+                total++;
+                if (kid === self)
+                    index = total;
+            }
+            parts.unshift(total > 1 ? `${tag}:nth-of-type(${index})` : tag);
+        }
+        else {
+            parts.unshift(tag);
+        }
+        n = up;
+    }
+    return parts.join('>');
+}
+const mask = (s) => s.replace(/\S/g, '*');
+/**
+ * A human-ish label: tag + short text, e.g. `button: Buy now`.
+ *
+ * `maskText` (from `privacy.maskEventText`) replaces every non-whitespace character with `*`, keeping
+ * the word shape. Exported so the unit tests can drive both branches directly.
+ */
+export function describe(el, maskText = false) {
+    const tag = el.tagName.toLowerCase();
+    const text = (el.textContent || '').trim().slice(0, 40);
+    if (!text)
+        return tag;
+    return `${tag}: ${maskText ? mask(text) : text}`;
+}
+/**
+ * A compact CSS-ish selector (tag#id.class) — structure only, no text/PII.
+ *
+ * Byte-identical to autocapture's copy, and DELIBERATELY left duplicated. Sharing it through a
+ * `core/` module was tried and measured: the eager bundle grew 136 B rather than shrinking, because
+ * gzip already collapses the second copy to almost nothing while a new module boundary costs real
+ * bytes. Deduplicate this only if the two lanes ever need to agree on the value, not to save space.
+ */
+function selectorOf(el) {
+    let s = el.tagName.toLowerCase();
+    if (el.id)
+        s += `#${el.id}`;
+    const cls = (el.getAttribute('class') || '')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .slice(0, 2);
+    if (cls.length)
+        s += '.' + cls.join('.');
+    return s;
+}
+/** The path the visitor is on, read at capture time. Undefined outside a browser. */
+function currentPath() {
+    try {
+        return typeof location !== 'undefined' ? location.pathname : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=InteractionTracker.js.map

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * F-JRN — journey + navigation. Emits SCREEN_VIEW (route changes) and USER_ACTION (clicks enriched with rage/dead
+ * friction) as `kind:'event'` items → the existing funnels / flows / friction analytics. Always-on,
+ * decoupled from replay.
+ */
+import type { IFeature, FeatureContext } from '@scalebun/sdk-contracts';
+export declare class JourneyFeature implements IFeature {
+    readonly name = "journey";
+    private ctx;
+    private active;
+    private nav?;
+    private interactions?;
+    get isActive(): boolean;
+    setup(ctx: FeatureContext): void;
+    private emit;
+    teardown(): void;
+}
+//# sourceMappingURL=JourneyFeature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JourneyFeature.d.ts","sourceRoot":"","sources":["../../../src/features/journey/JourneyFeature.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAOxE,qBAAa,cAAe,YAAW,QAAQ;IAC7C,QAAQ,CAAC,IAAI,aAAa;IAC1B,OAAO,CAAC,GAAG,CAA+B;IAC1C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,GAAG,CAAC,CAAoB;IAChC,OAAO,CAAC,YAAY,CAAC,CAAqB;IAE1C,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,IAAI;IA8BhC,OAAO,CAAC,IAAI;IA0BZ,QAAQ,IAAI,IAAI;CAKjB"}