@scalebun-release/web 2.2.2

package/dist/features/webperf/collectors.js

@@ -0,0 +1,118 @@
+// Web-perf collectors (page-load / FPS / LoAF) — the LAZY chunk. Loaded by WebPerfFeature.setup so the
+// observer/rAF wiring stays out of the core bundle. Returns a stop() that tears everything down.
+import { fpsFromFrames, loafSeverity, navMetric } from './math.js';
+const FPS_WINDOW_MS = 5000;
+const FPS_GAP_MS = 25000;
+const LOAF_MIN_MS = 50;
+const MEM_GAP_MS = 30000; // JS-heap sample cadence (Chromium `performance.memory`)
+export function startCollectors(emit, isActive) {
+    let observer;
+    let raf;
+    let fpsTimer;
+    let memTimer;
+    let onLoad;
+    // Sample used JS-heap on a slow cadence → the 'memory' PerformanceMetric the High-Memory KPI counts.
+    // `performance.memory` is Chromium-only + non-standard; degrades to a no-op elsewhere (never throws).
+    const sampleMemory = () => {
+        if (!isActive())
+            return;
+        try {
+            const mem = performance.memory;
+            const used = mem?.usedJSHeapSize;
+            if (typeof used === 'number' && used > 0) {
+                emit('memory', used, { kind: 'js_heap', totalHeap: mem?.totalJSHeapSize, heapLimit: mem?.jsHeapSizeLimit });
+            }
+        }
+        catch {
+            /* performance.memory unavailable */
+        }
+        memTimer = setTimeout(sampleMemory, MEM_GAP_MS);
+    };
+    const capturePageLoad = () => {
+        try {
+            const navs = performance.getEntriesByType?.('navigation');
+            const nav = navs?.[0];
+            if (!nav || nav.loadEventEnd <= 0)
+                return;
+            const m = navMetric(nav);
+            emit('screen_load', m.value, m.metadata, m.value);
+        }
+        catch {
+            /* Navigation Timing unavailable */
+        }
+    };
+    const startLoaf = () => {
+        const PO = window.PerformanceObserver;
+        if (!PO)
+            return;
+        const types = PO.supportedEntryTypes ?? [];
+        const useLoaf = types.includes('long-animation-frame');
+        const useLongtask = !useLoaf && types.includes('longtask');
+        if (!useLoaf && !useLongtask)
+            return;
+        try {
+            const obs = new PO((list) => {
+                for (const e of list.getEntries()) {
+                    const blocking = useLoaf ? (e.blockingDuration ?? 0) : e.duration;
+                    if (blocking < LOAF_MIN_MS)
+                        continue;
+                    emit('js_stall', Math.round(blocking), { kind: useLoaf ? 'loaf' : 'longtask', severity: loafSeverity(blocking) }, Math.round(e.duration));
+                }
+            });
+            obs.observe({ type: useLoaf ? 'long-animation-frame' : 'longtask', buffered: true });
+            observer = obs;
+        }
+        catch {
+            /* observer type unsupported */
+        }
+    };
+    const sampleFps = () => {
+        if (!isActive())
+            return;
+        if ((typeof document !== 'undefined' && document.visibilityState !== 'visible') || typeof requestAnimationFrame === 'undefined') {
+            fpsTimer = setTimeout(sampleFps, FPS_GAP_MS);
+            return;
+        }
+        let frames = 0;
+        const start = performance.now();
+        const tick = () => {
+            if (!isActive())
+                return;
+            frames++;
+            const elapsed = performance.now() - start;
+            if (elapsed < FPS_WINDOW_MS) {
+                raf = requestAnimationFrame(tick);
+            }
+            else {
+                const { fps, dropped } = fpsFromFrames(frames, elapsed);
+                emit('frame_metrics', fps, { totalFrames: frames, dropped, windowMs: Math.round(elapsed) });
+                fpsTimer = setTimeout(sampleFps, FPS_GAP_MS);
+            }
+        };
+        raf = requestAnimationFrame(tick);
+    };
+    if (document.readyState === 'complete') {
+        setTimeout(capturePageLoad, 0);
+    }
+    else {
+        onLoad = () => setTimeout(capturePageLoad, 0);
+        window.addEventListener('load', onLoad, { once: true });
+    }
+    startLoaf();
+    fpsTimer = setTimeout(sampleFps, FPS_GAP_MS);
+    // Only arm the memory sampler when the API exists, so unsupported browsers don't spin an idle timer.
+    if (performance.memory)
+        memTimer = setTimeout(sampleMemory, MEM_GAP_MS);
+    return () => {
+        observer?.disconnect();
+        if (raf != null && typeof cancelAnimationFrame !== 'undefined')
+            cancelAnimationFrame(raf);
+        if (fpsTimer)
+            clearTimeout(fpsTimer);
+        if (memTimer)
+            clearTimeout(memTimer);
+        if (onLoad && typeof window !== 'undefined')
+            window.removeEventListener('load', onLoad);
+    };
+}
+//# sourceMappingURL=collectors.js.map

package/dist/features/webperf/collectors.js.map

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

package/dist/features/webperf/math.d.ts

@@ -0,0 +1,12 @@
+export declare function loafSeverity(blockingMs: number): 'info' | 'warning' | 'critical';
+/** Frames counted over a window → estimated fps (cap 60) + dropped count. */
+export declare function fpsFromFrames(frames: number, windowMs: number): {
+    fps: number;
+    dropped: number;
+};
+/** Page-load metric from a Navigation Timing entry. */
+export declare function navMetric(nav: PerformanceNavigationTiming): {
+    value: number;
+    metadata: Record<string, unknown>;
+};
+//# sourceMappingURL=math.d.ts.map

package/dist/features/webperf/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../../src/features/webperf/math.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,CAEhF;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAKhG;AAED,uDAAuD;AACvD,wBAAgB,SAAS,CAAC,GAAG,EAAE,2BAA2B,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAWhH"}

package/dist/features/webperf/math.js

@@ -0,0 +1,26 @@
+// Pure web-perf math — shared by the (lazy) collectors and the unit tests.
+export function loafSeverity(blockingMs) {
+    return blockingMs >= 200 ? 'critical' : blockingMs >= 100 ? 'warning' : 'info';
+}
+/** Frames counted over a window → estimated fps (cap 60) + dropped count. */
+export function fpsFromFrames(frames, windowMs) {
+    if (windowMs <= 0)
+        return { fps: 0, dropped: 0 };
+    const fps = Math.min(60, Math.round((frames / windowMs) * 1000));
+    const expected = Math.round((windowMs / 1000) * 60);
+    return { fps, dropped: Math.max(0, expected - frames) };
+}
+/** Page-load metric from a Navigation Timing entry. */
+export function navMetric(nav) {
+    const load = Math.round(nav.loadEventEnd || nav.duration);
+    return {
+        value: load,
+        metadata: {
+            kind: 'page_load',
+            ttfb: Math.round(nav.responseStart),
+            dcl: Math.round(nav.domContentLoadedEventEnd),
+            navType: nav.type,
+        },
+    };
+}
+//# sourceMappingURL=math.js.map

package/dist/features/webperf/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sourceRoot":"","sources":["../../../src/features/webperf/math.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAE3E,MAAM,UAAU,YAAY,CAAC,UAAkB;IAC7C,OAAO,UAAU,IAAI,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,IAAI,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC;AACjF,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,aAAa,CAAC,MAAc,EAAE,QAAgB;IAC5D,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IACjD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACjE,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,EAAE,CAAC;AAC1D,CAAC;AAED,uDAAuD;AACvD,MAAM,UAAU,SAAS,CAAC,GAAgC;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1D,OAAO;QACL,KAAK,EAAE,IAAI;QACX,QAAQ,EAAE;YACR,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC;YACnC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,wBAAwB,CAAC;YAC7C,OAAO,EAAE,GAAG,CAAC,IAAI;SAClB;KACF,CAAC;AACJ,CAAC"}

package/dist/inapp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Subpath entry for `@scalebun/web/inapp` — the In-App Messaging 2.0 public API. Kept separate from
+ * the size-gated `index.ts` so none of the IAM engine loads into the eager core bundle.
+ */
+export * from './features/inapp/index.js';
+//# sourceMappingURL=inapp.d.ts.map

package/dist/inapp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inapp.d.ts","sourceRoot":"","sources":["../src/inapp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,kBAAkB,CAAC"}

package/dist/inapp.js

@@ -0,0 +1,6 @@
+/**
+ * Subpath entry for `@scalebun/web/inapp` — the In-App Messaging 2.0 public API. Kept separate from
+ * the size-gated `index.ts` so none of the IAM engine loads into the eager core bundle.
+ */
+export * from './features/inapp/index.js';
+//# sourceMappingURL=inapp.js.map

package/dist/inapp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inapp.js","sourceRoot":"","sources":["../src/inapp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,kBAAkB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @scalebun/web — Public entry point.
+ *
+ * The ONLY module consumers import from. Mirrors the RN SDK's single public surface.
+ *
+ *   import ScaleBun from '@scalebun/web';
+ *   await ScaleBun.init({ clientKey: 'pk_xxx', apiBaseUrl: 'https://api.scalebun.com/api/v1' });
+ *
+ * 🚧 Scaffold: the facade is stubbed; capture features are not implemented yet.
+ */
+export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade.js';
+export type { ScaleBunInitConfig, ScaleBunFeatures, ScaleBunUser, PrivacyConfig, } from '@scalebun/sdk-contracts';
+/** Business telemetry contracts shared with the React Native SDK. */
+export type { RevenueInput, RevenueType, NormalizedRevenue } from './features/analytics/revenue.js';
+export type { SubscriptionInput, SubscriptionPlan, SubscriptionStatus } from './features/analytics/subscription.js';
+/**
+ * The gamified in-app contract, so a host can type its `onInAppGameRequest` handler — and share one
+ * implementation with the React Native SDK, where these types are identical.
+ *
+ * TYPES ONLY: `export type` erases at build time, so this adds nothing to the bundle.
+ */
+export type { InAppGameRequest, InAppGameResult, InAppGameOutcome, InAppGameAction, InAppGameVariantKey, InAppGameRequestHandler, } from './features/engage/gameTypes.js';
+/**
+ * Inbox contracts, so a host can render the message list in its OWN design system.
+ *
+ * ⚠️ These were unreachable from the package root, which quietly forced every headless integration
+ * to be untyped — the one path the inbox is explicitly built for ("UI is opt-in; hosts that render
+ * their own never pay for the widget"). A headless-first feature whose types are private is
+ * headless-first in name only.
+ *
+ * TYPES ONLY — `export type` erases at build time, so this costs zero bytes.
+ */
+export type { InboxMessage, InboxController, InboxState, InboxCta, InboxQueryOptions, InboxPage, InboxMessageState, InboxSyncStatus, InboxMountOptions, InboxLabels, InboxLayout, } from './features/inbox/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAGxE,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,aAAa,GACd,MAAM,yBAAyB,CAAC;AAEjC,qEAAqE;AACrE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjG,YAAY,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEjH;;;;;GAKG;AACH,YAAY,EACV,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;GASG;AACH,YAAY,EACV,YAAY,EACZ,eAAe,EACf,UAAU,EACV,QAAQ,EACR,iBAAiB,EACjB,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,WAAW,GACZ,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * @scalebun/web — Public entry point.
+ *
+ * The ONLY module consumers import from. Mirrors the RN SDK's single public surface.
+ *
+ *   import ScaleBun from '@scalebun/web';
+ *   await ScaleBun.init({ clientKey: 'pk_xxx', apiBaseUrl: 'https://api.scalebun.com/api/v1' });
+ *
+ * 🚧 Scaffold: the facade is stubbed; capture features are not implemented yet.
+ */
+export { ScaleBun as default, ScaleBun } from './public/ScaleBunFacade.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/integrations/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * integrations/ — framework router hooks + glue consumed by the adapter packages
+ * (@scalebun/web-react, /vue, /next, …). Auto route/page-name detection lives here.
+ * 🚧 SCAFFOLD: not implemented yet.
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/integrations/index.js

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

package/dist/integrations/index.js.map

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

package/dist/pipeline/index.d.ts

@@ -0,0 +1,3 @@
+/** pipeline/ — the single unified egress (envelope → queue → batch → flush). */
+export * from './pipeline.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipeline/index.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,cAAc,YAAY,CAAC"}

package/dist/pipeline/index.js

@@ -0,0 +1,3 @@
+/** pipeline/ — the single unified egress (envelope → queue → batch → flush). */
+export * from './pipeline.js';
+//# sourceMappingURL=index.js.map

package/dist/pipeline/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/pipeline/index.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,cAAc,YAAY,CAAC"}

package/dist/pipeline/pipeline.d.ts

@@ -0,0 +1,263 @@
+/**
+ * THE pipeline — the SDK's single egress. Every feature emits Items here; this batches them into
+ * SessionEnvelopes and flushes on a timer / on page-hide. At-least-once: a failed batch is
+ * re-queued and mirrored to IndexedDB so it survives a reload.
+ */
+import type { Item } from '@scalebun/protocol';
+import type { ResolvedConfig } from '../config/schema.js';
+import type { SessionManager } from '../features/session/sessionManager.js';
+import type { HttpClient } from '../transport/httpClient.js';
+export declare class Pipeline {
+    private readonly config;
+    private readonly session;
+    private readonly transport;
+    private queue;
+    private timer;
+    private droppedCount;
+    /**
+     * P6 — the egress ledger. `pending` and `dropped` alone could not answer the question the
+     * reliability work kept running into: recovery demonstrably WORKS (frames arrive with a capture-to-
+     * storage gap of up to 12.8 hours, which only a durable queue draining on a later visit produces)
+     * and its contribution was completely uncountable, so it could never be separated from ordinary
+     * delivery or defended when someone asked whether it was worth its bytes.
+     *
+     * `expired` is split out of `dropped` deliberately. Age-pruning a queue the app sat on for days is
+     * correct behaviour; evicting a live item because the queue overflowed is data loss. Counting both
+     * as "dropped" made a healthy reload look like a leak, which is how a real signal gets ignored.
+     */
+    private queuedCount;
+    private attemptedCount;
+    private retriedCount;
+    private recoveredCount;
+    private expiredCount;
+    private ackedCount;
+    private started;
+    private consentGranted;
+    private dead;
+    private lifecycle;
+    private readonly buffer;
+    private readonly backoff;
+    /** True while a flush is awaiting the network. Prevents two flushes (timer + pagehide/keepalive)
+     *  from each splicing a different batch out of the queue. Parity with the in-app transport and the
+     *  RN EventTracker, which both guard; the session lane was the gap. */
+    private flushing;
+    /** Resolves once the server has a session row for these items to attach to. Every flush awaits it
+     *  — see start(). Pre-resolved so a flush before start() (or after stop()) is not deadlocked. */
+    private sessionStarted;
+    /** True once session-create has actually succeeded. See `armSession()`. */
+    private sessionOk;
+    /** Re-arm attempts spent. Bounded so a permanently-refusing server costs a few extra requests
+     *  rather than one per flush for the life of the page. */
+    private sessionRetries;
+    /** A keyframe wanted the fast path while a batch was in flight — drain again on completion. */
+    private keyframePending;
+    /**
+     * Kinds already reported via `sdk_replay_capture_failed`, so the report is emitted ONCE per kind.
+     *
+     * Load-bearing, not tidiness. The report is itself an `event` item on this same queue: if the
+     * `event` kind is what the server is refusing, an unlatched report would emit an event, watch it be
+     * dropped, and emit another — a queue that grows on its own failure. The latch bounds the whole
+     * mechanism to one item per kind per session.
+     */
+    private reported?;
+    /** The batch currently being sent. It is NOT in `queue`, so persistence must still see it — if the
+     *  page dies mid-send, that fetch is cancelled and the re-queue never runs. */
+    private inFlight;
+    constructor(config: ResolvedConfig, session: SessionManager, transport: HttpClient);
+    /** Open/close the consent egress gate. Opening alone does not start the flush loop (see start()). */
+    setConsentGranted(granted: boolean): void;
+    /** Whether egress is currently allowed (consent open + not discarded). Direct-send paths that
+     *  bypass emit() (e.g. reportBug) MUST honor this so they don't leak under consent denial. */
+    canEgress(): boolean;
+    start(): Promise<void>;
+    /**
+     * Issue session-create and hold the gate on it.
+     *
+     * Separate from `start()` because it must be RE-ISSUABLE. It ran exactly once, with its rejection
+     * swallowed by a bare `.catch(() => {})`, so a session-create that failed — offline at boot, a 5xx,
+     * a CORS misconfiguration — left a gate that resolved happily onto a session row the server did not
+     * have. Every subsequent batch was then rejected as `unknown_session`, which is retryable, so the
+     * pipeline retried the same items against a row that nothing was ever going to create. The one
+     * request that could have fixed it was the one request never sent again.
+     *
+     * `sessionOk` is what flush() reads to decide whether re-arming is worth a try; it is false both
+     * before the first attempt resolves and after a failed one.
+     */
+    private armSession;
+    /**
+     * Open the session lane again under the SessionManager's CURRENT id, after a rotation.
+     *
+     * `start()` cannot serve here: it latches on `started` and also drains the persisted buffer, which
+     * belongs to a previous page load and not to a session that began a moment ago in this one. All a
+     * rotation needs is the row — and it genuinely needs it, because the batch endpoint answers 200
+     * while dropping every item of a session it has no row for. `unknown_session` is already the
+     * largest rejection reason in production; rotating without this would make every post-rotation
+     * item join it.
+     *
+     * The retry budget resets with the session: a create that failed for the previous id says nothing
+     * about this one.
+     */
+    restart(): Promise<void>;
+    /**
+     * Make room by dropping the OLDEST REPLAY CHAIN whole, instead of one interior delta.
+     *
+     * THE BUG THIS FIXES. This used to evict the oldest DELTA frame, reasoning that a keyframe costs
+     * more to lose and that "the player interpolates across a gap". The player does not interpolate:
+     * `applyMutations` looks the node up, finds nothing, increments `NodeRegistry.misses` and skips the
+     * operation — so the element that mutation would have created never exists, and every later
+     * reference to it misses too. One evicted delta therefore corrupts the rest of the chain, which is
+     * why 1.16% frame loss measured on production put a `Partial reconstruction` badge on 13.5% of
+     * sessions. Loss was rare; it just was not survivable.
+     *
+     * So the unit of eviction is the CHAIN, exactly as `SegmentBuffer` already does for the pre-roll:
+     * drop every frame from the head up to (not including) the next keyframe, and nothing else. What
+     * remains is either intact or is about to be — see the `shed` checkpoint in the recorder, which
+     * opens a fresh chain the moment this fires. Non-frame items are stepped over, never dropped: an
+     * event or a network record has no chain to belong to and its loss buys no room worth having.
+     *
+     * Dropping many items at once is deliberate. A single-item eviction ran again on the very next
+     * emit, so a full queue shed continuously; freeing a whole chain (bounded by the recorder's
+     * 120-frame checkpoint) means this runs once per chain rather than once per frame.
+     */
+    private evictChain;
+    emit(item: Item): void;
+    /**
+     * Say that data was thrown away, on the one lane proven to work.
+     *
+     * A permanent rejection is real, unrecoverable data loss — an 8 MB keyframe or a closed entitlement
+     * will be refused identically forever, so the only correct action is to drop it. Dropping it
+     * SILENTLY is what made the `missing` replay bucket undiagnosable: replay produced nothing, and
+     * neither the client nor the server had anything to say about why. `dropped` alone cannot carry it
+     * either, since it already means "queue overflow".
+     *
+     * Same event name as the React Native SDK (`sdk_replay_capture_failed`), with platform-specific
+     * `reason` values, so one dashboard breakdown reads both platforms without a concept-map alias.
+     *
+     * Emitted through `emit()` on purpose: it inherits the durable queue, the consent gate and the
+     * batching that every other item gets. Latched to once per kind — see `reported`.
+     */
+    private reportDrop;
+    /** Persist the pending queue to IDB, trimmed to the byte budget (replay frames shed first so a
+     *  few large keyframes can't blow the IndexedDB quota). */
+    private persistQueue;
+    /** Auto (timer/reconnect-driven) flush: skip while offline or inside the backoff window so a
+     *  struggling/offline server isn't hit every tick. Explicit/keepalive flushes bypass this. */
+    private autoFlush;
+    /**
+     * Empty the queue, instead of taking one batch and waiting out the next tick.
+     *
+     * THE CEILING THIS REMOVES. `flush()` takes `maxBatchSize` items (50) and the timer fires every
+     * `flushIntervalMs` (5,000 ms), so sustained egress was pinned at TEN ITEMS PER SECOND. Capture
+     * runs above that on any active page — the DOM lane packages a frame every 100 ms, scroll and
+     * input flush every 100 ms, cursor moves every 300 ms, and clicks flush immediately. Production
+     * bears out the pressure: the current SDK records 40 frames per session at the median against the
+     * previous version's 13. A queue that fills faster than it drains reaches `maxQueueSize` and starts
+     * shedding, which is the upstream cause of most of the frame loss this lane exists to fix.
+     *
+     * Draining stops the moment the queue stops SHRINKING, so a failing or backing-off transport costs
+     * one attempt rather than a spin: `flush()` puts a failed batch back, the length does not fall, and
+     * the loop exits. `MAX_DRAIN_BATCHES` bounds the pathological case where items are emitted as fast
+     * as they are sent — the queue is capped at 1,000, so 20 batches empties a full one.
+     *
+     * NOT used for the unload path. Keepalive bodies share a single 64 KiB in-flight budget across the
+     * whole agent, so issuing several at once would fail them all; `persistAndFlush` still sends one.
+     */
+    drain(): Promise<void>;
+    /**
+     * Take as much of the queue as a KEEPALIVE request can actually carry.
+     *
+     * THE BUG THIS FIXES. The unload flush took `maxBatchSize` items like any other, and `httpClient`
+     * skips gzip on the keepalive path — on the stated grounds that "keepalive bodies are small". They
+     * are not: this is the same 50-item batch as a normal tick, replay keyframes included, sent as raw
+     * JSON. Fetch caps the total in-flight keepalive body at 64 KiB and returns a NETWORK ERROR past
+     * it, so an oversized unload flush did not truncate — it failed whole, and the tail of the session
+     * only ever arrived if the visitor came back in the same browser. That is the "the replay ends
+     * before the session does" report.
+     *
+     * Sizing by serialized bytes and stopping at the budget delivers what fits and leaves the rest in
+     * the queue, where `persistQueue()` — which pagehide already ran before calling us — has it safe
+     * for the next load. Partial delivery beats none.
+     *
+     * ALWAYS AT LEAST ONE ITEM, even one over budget on its own: a head item too large to fit would
+     * otherwise block the queue permanently, and sending it costs no more than the failure it replaces.
+     *
+     * Gzip is deliberately still not the answer here. `CompressionStream` is async, and awaiting it
+     * inside a pagehide handler races the document's teardown — the request would be built after the
+     * page is gone. A deterministic byte budget needs no such bet.
+     */
+    private takeKeepalive;
+    /** Drain a batch. On failure, re-queue (front) + persist so nothing is lost, and widen the
+     *  backoff window; on success, collapse the window back to the base interval. */
+    flush(opts?: {
+        keepalive?: boolean;
+    }): Promise<void>;
+    /**
+     * Ship a queue recovered from a PREVIOUS session under that session's own id.
+     *
+     * The transport derives the URL from `envelope.sessionId`, so overriding it is all that is needed
+     * to file the frames where they belong. Sent in its own envelope rather than merged into the
+     * current queue, because a batch may only describe one session.
+     *
+     * On failure the items are written back for one more attempt. That retry window lasts until this
+     * page's own `persistQueue()` overwrites the slot (its first page-hide or failed flush) — a single
+     * buffer entry cannot hold two sessions, and giving orphans their own key is not worth the eager
+     * bytes. Re-persisting under the ORIGINAL id, rather than folding them into the live queue, is the
+     * deliberate call: losing a few frames from a session the user already left beats interleaving
+     * foreign seq numbers into the replay of the session they are in right now.
+     */
+    /**
+     * File a single item against another session — the same orphan lane, for a signal rather than a
+     * recovered queue. Used by crash recovery to report a dead session's death ON that session
+     * instead of on the live one. Fire-and-forget: it must never block the current session's setup.
+     */
+    emitFor(sid: string, item: Item): void;
+    /**
+     * Ship a recovered queue under the session it belongs to — IN BATCHES, not as one envelope.
+     *
+     * THE BUG THIS FIXES. This sent `items` whole, and `items` here is a queue recovered from a
+     * previous page load: up to `maxQueueSize`, a thousand items. The frame endpoint accepts 100 per
+     * request and answers `batch_too_large` past that, which the backend deliberately classifies as
+     * RETRYABLE — "the right data in a request that was too big", to be split and resent. Nothing
+     * implemented the split, so the identical oversized envelope went back to the buffer and returned
+     * on the next load to fail the same way. Measured in production over one week: 232 frame items
+     * across 2 sessions, rejected exactly this way.
+     *
+     * Chunking at `maxBatchSize` makes the split unnecessary rather than merely handled — the request
+     * is never oversized in the first place. Sequential, because these are a dead session's tail and
+     * have no claim on the live session's bandwidth.
+     *
+     * Everything not taken accumulates and is saved ONCE at the end: the orphan buffer is a single
+     * slot, so a save per chunk would leave only the last chunk's leftovers in it.
+     */
+    private drainOrphans;
+    private buildEnvelope;
+    private installLifecycleFlush;
+    private addLifecycle;
+    private removeLifecycle;
+    stop(): Promise<void>;
+    /**
+     * Drop everything without sending — for consent denial. Stops the flush loop, discards the
+     * in-memory queue, and purges the persisted buffer (including any data from a prior load). Unlike
+     * stop(), it never flushes or finalizes (no network), so nothing leaves the browser.
+     */
+    discard(): Promise<void>;
+    get pendingCount(): number;
+    get dropped(): number;
+    /**
+     * P6 — the full egress ledger, for `ScaleBun.egressStats()`.
+     *
+     * Exposed as one object rather than seven getters so a caller reads a CONSISTENT snapshot: the
+     * counters move on network callbacks, and seven separate reads could straddle a flush and produce a
+     * set that never actually existed.
+     */
+    get ledger(): {
+        queued: number;
+        attempted: number;
+        retried: number;
+        recovered: number;
+        dropped: number;
+        expired: number;
+        acked: number;
+    };
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/pipeline/pipeline.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAmB,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AA8C1D,qBAAa,QAAQ;IA4DjB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IA7D5B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,YAAY,CAAK;IACzB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAS;IAGxB,OAAO,CAAC,cAAc,CAAU;IAGhC,OAAO,CAAC,IAAI,CAAS;IAErB,OAAO,CAAC,SAAS,CAAuE;IACxF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IACjD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAiB;IACzC;;2EAEuE;IACvE,OAAO,CAAC,QAAQ,CAAS;IACzB;qGACiG;IACjG,OAAO,CAAC,cAAc,CAAuC;IAC7D,2EAA2E;IAC3E,OAAO,CAAC,SAAS,CAAS;IAC1B;8DAC0D;IAC1D,OAAO,CAAC,cAAc,CAAK;IAC3B,+FAA+F;IAC/F,OAAO,CAAC,eAAe,CAAS;IAChC;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B;mFAC+E;IAC/E,OAAO,CAAC,QAAQ,CAAc;gBAGX,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,UAAU;IAKxC,qGAAqG;IACrG,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAIzC;kGAC8F;IAC9F,SAAS,IAAI,OAAO;IAId,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgD5B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,UAAU;IAgBlB;;;;;;;;;;;;OAYG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,UAAU;IAoBlB,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IA+CtB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,UAAU;IAkBlB;+DAC2D;IAC3D,OAAO,CAAC,YAAY;IAepB;kGAC8F;IAC9F,OAAO,CAAC,SAAS;IAKjB;;;;;;;;;;;;;;;;;;OAkBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,OAAO,CAAC,aAAa;IAYrB;qFACiF;IAC3E,KAAK,CAAC,IAAI,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAkL1D;;;;;;;;;;;;;OAaG;IACH;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI;IAStC;;;;;;;;;;;;;;;;;OAiBG;YACW,YAAY;IA8B1B,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,qBAAqB;IAsB7B,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,eAAe;IAWjB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3B;;;;OAIG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAe9B,IAAI,YAAY,IAAI,MAAM,CAEzB;IACD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;;;;OAMG;IACH,IAAI,MAAM,IAAI;QACZ,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;KACf,CAUA;CACF"}