npm - @squasher-ai/browser - Versions diffs - 0.1.1 → 0.3.0 - Mend

@squasher-ai/browser 0.1.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (109) hide show

package/LICENSE +21 -21
package/README.md +3 -42
package/dist/_vendor/result-runtime/attempt.d.ts +17 -0
package/dist/_vendor/result-runtime/attempt.js +62 -0
package/dist/_vendor/sdk-runtime/batching/index.d.ts +42 -0
package/dist/_vendor/sdk-runtime/batching/index.js +48 -0
package/dist/_vendor/sdk-runtime/errors/headers.d.ts +6 -0
package/dist/_vendor/sdk-runtime/errors/headers.js +44 -0
package/dist/_vendor/sdk-runtime/errors/index.d.ts +95 -0
package/dist/_vendor/sdk-runtime/errors/index.js +157 -0
package/dist/_vendor/sdk-runtime/headers.d.ts +48 -0
package/dist/_vendor/sdk-runtime/headers.js +67 -0
package/dist/_vendor/sdk-runtime/platform.d.ts +33 -0
package/dist/_vendor/sdk-runtime/platform.js +173 -0
package/dist/_vendor/sdk-runtime/retry.d.ts +50 -0
package/dist/_vendor/sdk-runtime/retry.js +104 -0
package/dist/_vendor/sdk-runtime/runtime/actionable-error.d.ts +37 -0
package/dist/_vendor/sdk-runtime/runtime/actionable-error.js +123 -0
package/dist/_vendor/sdk-runtime/runtime/environment.d.ts +18 -0
package/dist/_vendor/sdk-runtime/runtime/environment.js +81 -0
package/dist/_vendor/sdk-runtime/runtime/public-sdk-runtime.d.ts +12 -0
package/dist/_vendor/sdk-runtime/runtime/public-sdk-runtime.js +38 -0
package/dist/_vendor/sdk-runtime/runtime/redaction.d.ts +14 -0
package/dist/_vendor/sdk-runtime/runtime/redaction.js +120 -0
package/dist/_vendor/sdk-runtime/runtime/release.d.ts +35 -0
package/dist/_vendor/sdk-runtime/runtime/release.js +120 -0
package/dist/_vendor/sdk-runtime/sampling/index.d.ts +43 -0
package/dist/_vendor/sdk-runtime/sampling/index.js +70 -0
package/dist/_vendor/telemetry-contract/sdk/public-contract.d.ts +175 -0
package/dist/_vendor/telemetry-contract/sdk/public-contract.js +5 -0
package/dist/autocapture.d.ts +14 -19
package/dist/autocapture.js +77 -95
package/dist/client.d.ts +12 -20
package/dist/client.js +56 -72
package/dist/config.d.ts +24 -0
package/dist/config.js +26 -0
package/dist/console-capture.d.ts +7 -0
package/dist/console-capture.js +79 -0
package/dist/errors.d.ts +2 -3
package/dist/errors.js +8 -5
package/dist/index.d.ts +5 -39
package/dist/index.js +4 -82
package/dist/next.d.ts +39 -0
package/dist/next.js +67 -0
package/dist/react.d.ts +0 -1
package/dist/react.js +12 -10
package/dist/replay-network.d.ts +20 -0
package/dist/replay-network.js +193 -0
package/dist/replay-privacy.d.ts +2 -3
package/dist/replay-privacy.js +47 -17
package/dist/replay-retry.d.ts +40 -0
package/dist/replay-retry.js +193 -0
package/dist/replay.d.ts +18 -6
package/dist/replay.js +131 -71
package/dist/runtime/client-singleton.d.ts +24 -0
package/dist/runtime/client-singleton.js +66 -0
package/dist/runtime/client.d.ts +21 -0
package/dist/runtime/client.js +12 -0
package/dist/runtime/replay.d.ts +12 -0
package/dist/runtime/replay.js +15 -0
package/dist/session.d.ts +0 -11
package/dist/session.js +20 -21
package/dist/telemetry.d.ts +1 -2
package/dist/telemetry.js +13 -10
package/dist/trace-context.d.ts +8 -0
package/dist/trace-context.js +13 -0
package/dist/transport.d.ts +11 -20
package/dist/transport.js +86 -66
package/dist/types.d.ts +38 -139
package/dist/types.js +0 -7
package/dist/vitals.d.ts +55 -3
package/dist/vitals.js +115 -16
package/package.json +11 -3
package/dist/__tests__/client.test.d.ts +0 -2
package/dist/__tests__/client.test.d.ts.map +0 -1
package/dist/__tests__/client.test.js +0 -103
package/dist/__tests__/errors.test.d.ts +0 -2
package/dist/__tests__/errors.test.d.ts.map +0 -1
package/dist/__tests__/errors.test.js +0 -80
package/dist/__tests__/replay-privacy.test.d.ts +0 -2
package/dist/__tests__/replay-privacy.test.d.ts.map +0 -1
package/dist/__tests__/replay-privacy.test.js +0 -124
package/dist/__tests__/replay-startup.test.d.ts +0 -2
package/dist/__tests__/replay-startup.test.d.ts.map +0 -1
package/dist/__tests__/replay-startup.test.js +0 -99
package/dist/__tests__/replay.test.d.ts +0 -2
package/dist/__tests__/replay.test.d.ts.map +0 -1
package/dist/__tests__/replay.test.js +0 -217
package/dist/__tests__/session.test.d.ts +0 -2
package/dist/__tests__/session.test.d.ts.map +0 -1
package/dist/__tests__/session.test.js +0 -46
package/dist/__tests__/transport.test.d.ts +0 -2
package/dist/__tests__/transport.test.d.ts.map +0 -1
package/dist/__tests__/transport.test.js +0 -101
package/dist/__tests__/types.test.d.ts +0 -2
package/dist/__tests__/types.test.d.ts.map +0 -1
package/dist/__tests__/types.test.js +0 -139
package/dist/autocapture.d.ts.map +0 -1
package/dist/client.d.ts.map +0 -1
package/dist/errors.d.ts.map +0 -1
package/dist/index.d.ts.map +0 -1
package/dist/react.d.ts.map +0 -1
package/dist/replay-privacy.d.ts.map +0 -1
package/dist/replay.d.ts.map +0 -1
package/dist/session.d.ts.map +0 -1
package/dist/telemetry.d.ts.map +0 -1
package/dist/transport.d.ts.map +0 -1
package/dist/types.d.ts.map +0 -1
package/dist/vitals.d.ts.map +0 -1

package/dist/next.js ADDED Viewed

@@ -0,0 +1,67 @@
+/**
+ * Next.js Web Vitals bridge for @squasher-ai/browser.
+ *
+ * Drop `<SquasherNextWebVitals />` into your root layout to capture both
+ * Core Web Vitals (LCP, CLS, INP, FCP, TTFB) and Next.js framework metrics
+ * (`Next.js-hydration`, `Next.js-route-change-to-render`, `Next.js-render`).
+ *
+ * The component hard-imports `next/web-vitals` and `next/navigation` so it
+ * is **only** valid in a Next.js app. Non-Next consumers should rely on the
+ * auto-collector that runs from `init()` and not import this module.
+ *
+ * Internally it bridges Next's `useReportWebVitals` hook into the existing
+ * browser client transport, suppressing the SDK's native `web-vitals`
+ * collector on mount so Core metrics aren't reported twice.
+ *
+ * Usage:
+ *   import { SquasherNextWebVitals } from '@squasher-ai/browser/next';
+ *
+ *   export default function RootLayout({ children }) {
+ *     return (
+ *       <html>
+ *         <body>
+ *           <SquasherNextWebVitals />
+ *           {children}
+ *         </body>
+ *       </html>
+ *     );
+ *   }
+ */
+"use client";
+import { usePathname } from "next/navigation";
+import { useReportWebVitals } from "next/web-vitals";
+import { useCallback, useEffect, useRef } from "react";
+import { getClient } from "./runtime/client-singleton.js";
+const SUPPORTED_WEB_VITALS = new Set(["CLS", "FCP", "INP", "LCP", "TTFB"]);
+function isSupportedWebVital(name) {
+    return SUPPORTED_WEB_VITALS.has(name);
+}
+export function SquasherNextWebVitals({ path } = {}) {
+    const pathname = usePathname();
+    const currentPath = path ?? pathname ?? "/";
+    const stabilizedPath = useRef(currentPath);
+    useEffect(() => {
+        stabilizedPath.current = currentPath;
+    }, [currentPath]);
+    useEffect(() => {
+        try {
+            getClient().suppressNativeVitalsCollection();
+        }
+        catch {
+            // Squasher SDK not initialized — nothing to suppress. Bridge still
+            // runs so the host can call init() asynchronously.
+        }
+    }, []);
+    const report = useCallback((metric) => {
+        if (!isSupportedWebVital(metric.name))
+            return;
+        try {
+            getClient().recordWebVital(metric, stabilizedPath.current);
+        }
+        catch {
+            // SDK not yet initialized; drop this metric rather than throw.
+        }
+    }, []);
+    useReportWebVitals(report);
+    return null;
+}

package/dist/react.d.ts CHANGED Viewed

@@ -29,4 +29,3 @@ export declare class SquasherErrorBoundary extends Component<Props, State> {
     render(): ReactNode;
 }
 export {};
-//# sourceMappingURL=react.d.ts.map

package/dist/react.js CHANGED Viewed

@@ -12,7 +12,8 @@
  *   </SquasherErrorBoundary>
  */
 import { Component } from "react";
-import { getClient } from "./index";
+import { attempt } from "./_vendor/result-runtime/attempt.js";
+import { getClient } from "./runtime/client-singleton.js";
 export class SquasherErrorBoundary extends Component {
     constructor(props) {
         super(props);
@@ -22,15 +23,16 @@ export class SquasherErrorBoundary extends Component {
         return { hasError: true };
     }
     componentDidCatch(error, errorInfo) {
-        try {
-            const client = getClient();
-            client.captureError(error, {
-                componentStack: errorInfo.componentStack ?? undefined,
-            });
-        }
-        catch {
-            // SDK not initialized — silently ignore
-        }
+        attempt({
+            try: () => {
+                const client = getClient();
+                const extra = {};
+                if (errorInfo.componentStack)
+                    extra.componentStack = errorInfo.componentStack;
+                client.captureError(error, extra);
+            },
+            catch: () => undefined,
+        });
         this.props.onError?.(error, errorInfo);
     }
     render() {

package/dist/replay-network.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+export interface ReplayNetworkEventPayload {
+    durationMs: number;
+    initiatorType: string;
+    method?: string;
+    pageUrl: string;
+    protocol?: string | null;
+    requestUrl: string;
+    source: "fetch" | "resource";
+    startOffsetMs: number;
+    statusCode?: number | null;
+    statusText?: string | null;
+    transferSize?: number | null;
+}
+export interface ReplayNetworkCaptureOptions {
+    debug: boolean;
+    emitCustomEvent?: (tag: string, payload: ReplayNetworkEventPayload) => void;
+    ignoredUrlPrefixes?: string[];
+    replayStartedAtMs: number;
+}
+export declare function installReplayNetworkCapture({ debug, emitCustomEvent, ignoredUrlPrefixes, replayStartedAtMs, }: ReplayNetworkCaptureOptions): () => void;

package/dist/replay-network.js ADDED Viewed

@@ -0,0 +1,193 @@
+import { attempt, attemptAsync } from "./_vendor/result-runtime/attempt.js";
+import { readRuntimeNumber, readRuntimeProperty, readRuntimeString } from "./_vendor/sdk-runtime/runtime/public-sdk-runtime.js";
+const NETWORK_EVENT_TAG = "squasher:network";
+const MAX_NETWORK_EVENTS = 400;
+function clampOffset(offsetMs) {
+    return Math.max(0, Math.round(offsetMs));
+}
+function roundDuration(durationMs) {
+    return Math.max(0, Math.round(durationMs));
+}
+function readFiniteNumber(value) {
+    return value !== null && value !== undefined && Number.isFinite(value) ? value : null;
+}
+function readFiniteString(value) {
+    return value && value.length > 0 ? value : null;
+}
+function getCurrentPageUrl() {
+    return globalThis.location?.href ?? "";
+}
+function shouldIgnoreRequestUrl(requestUrl, ignoredUrlPrefixes) {
+    return ignoredUrlPrefixes.some((prefix) => requestUrl.startsWith(prefix));
+}
+function toResourceKey(payload) {
+    return [
+        payload.source,
+        payload.requestUrl,
+        payload.initiatorType,
+        payload.startOffsetMs,
+        payload.durationMs,
+    ].join("|");
+}
+function buildResourcePayload(entry, replayStartedAtMs) {
+    if (entry.entryType !== "resource" && entry.entryType !== "navigation") {
+        return null;
+    }
+    const initiatorType = readRuntimeString(readRuntimeProperty(entry, "initiatorType"));
+    const nextHopProtocol = readRuntimeString(readRuntimeProperty(entry, "nextHopProtocol"));
+    const renderBlockingStatus = readRuntimeString(readRuntimeProperty(entry, "renderBlockingStatus"));
+    const responseStatus = readRuntimeNumber(readRuntimeProperty(entry, "responseStatus"));
+    const transferSize = readRuntimeNumber(readRuntimeProperty(entry, "transferSize"));
+    const absoluteStartMs = performance.timeOrigin + entry.startTime;
+    return {
+        durationMs: roundDuration(entry.duration),
+        initiatorType: entry.entryType === "navigation"
+            ? "navigation"
+            : readFiniteString(initiatorType) || "resource",
+        pageUrl: getCurrentPageUrl(),
+        protocol: readFiniteString(nextHopProtocol),
+        requestUrl: entry.name,
+        source: "resource",
+        startOffsetMs: clampOffset(absoluteStartMs - replayStartedAtMs),
+        statusCode: readFiniteNumber(responseStatus),
+        statusText: readFiniteString(renderBlockingStatus),
+        transferSize: readFiniteNumber(transferSize),
+    };
+}
+export function installReplayNetworkCapture({ debug, emitCustomEvent, ignoredUrlPrefixes = [], replayStartedAtMs, }) {
+    if (!emitCustomEvent || !globalThis.window) {
+        return () => undefined;
+    }
+    let emittedCount = 0;
+    let customEventAvailable = true;
+    const seenResources = new Set();
+    const cleanups = [];
+    const emit = (payload) => {
+        if (!customEventAvailable || emittedCount >= MAX_NETWORK_EVENTS) {
+            return;
+        }
+        const emitted = attempt({
+            try: () => {
+                emitCustomEvent(NETWORK_EVENT_TAG, payload);
+                return true;
+            },
+            catch: ({ error }) => {
+                customEventAvailable = false;
+                if (debug) {
+                    console.warn("[squasher] Replay network event capture disabled", {
+                        error: error.message,
+                    });
+                }
+                return false;
+            },
+        });
+        if (!emitted)
+            return;
+        emittedCount += 1;
+        if (debug) {
+            console.log("[squasher] Replay network event recorded", {
+                requestUrl: payload.requestUrl,
+                source: payload.source,
+                statusCode: payload.statusCode ?? null,
+            });
+        }
+    };
+    if (globalThis.PerformanceObserver) {
+        const supportedEntryTypes = globalThis.PerformanceObserver.supportedEntryTypes ?? [];
+        const observer = new globalThis.PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+                const payload = buildResourcePayload(entry, replayStartedAtMs);
+                if (!payload) {
+                    continue;
+                }
+                if (shouldIgnoreRequestUrl(payload.requestUrl, ignoredUrlPrefixes)) {
+                    continue;
+                }
+                const absoluteStartMs = performance.timeOrigin + entry.startTime;
+                if (payload.initiatorType === "fetch" && absoluteStartMs >= replayStartedAtMs) {
+                    continue;
+                }
+                const key = toResourceKey(payload);
+                if (seenResources.has(key)) {
+                    continue;
+                }
+                seenResources.add(key);
+                emit(payload);
+            }
+        });
+        attempt({
+            try: () => {
+                if (supportedEntryTypes.includes("navigation")) {
+                    observer.observe({ buffered: true, type: "navigation" });
+                }
+                if (supportedEntryTypes.includes("resource")) {
+                    observer.observe({ buffered: true, type: "resource" });
+                }
+                cleanups.push(() => observer.disconnect());
+            },
+            catch: () => {
+                observer.disconnect();
+            },
+        });
+    }
+    if (window.fetch) {
+        const originalFetch = window.fetch.bind(window);
+        window.fetch = async (input, init) => {
+            const requestStartedAtMs = Date.now();
+            const inputIsRequest = globalThis.Request && input instanceof globalThis.Request;
+            const method = init?.method?.toUpperCase() || (inputIsRequest ? input.method.toUpperCase() : "GET");
+            const requestUrl = Object.prototype.toString.call(input) === "[object String]"
+                ? String(input)
+                : input instanceof URL
+                    ? input.href
+                    : inputIsRequest
+                        ? input.url
+                        : String(input);
+            const pageUrl = getCurrentPageUrl();
+            if (shouldIgnoreRequestUrl(requestUrl, ignoredUrlPrefixes)) {
+                return originalFetch(input, init);
+            }
+            return attemptAsync({
+                try: async () => {
+                    const response = await originalFetch(input, init);
+                    emit({
+                        durationMs: roundDuration(Date.now() - requestStartedAtMs),
+                        initiatorType: "fetch",
+                        method,
+                        pageUrl,
+                        requestUrl,
+                        source: "fetch",
+                        startOffsetMs: clampOffset(requestStartedAtMs - replayStartedAtMs),
+                        statusCode: response.status,
+                        statusText: response.statusText || null,
+                        transferSize: null,
+                    });
+                    return response;
+                },
+                catch: ({ cause, error }) => {
+                    emit({
+                        durationMs: roundDuration(Date.now() - requestStartedAtMs),
+                        initiatorType: "fetch",
+                        method,
+                        pageUrl,
+                        requestUrl,
+                        source: "fetch",
+                        startOffsetMs: clampOffset(requestStartedAtMs - replayStartedAtMs),
+                        statusCode: null,
+                        statusText: error.message || "network error",
+                        transferSize: null,
+                    });
+                    throw cause;
+                },
+            });
+        };
+        cleanups.push(() => {
+            window.fetch = originalFetch;
+        });
+    }
+    return () => {
+        for (const cleanup of cleanups) {
+            cleanup();
+        }
+    };
+}

package/dist/replay-privacy.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
-import type { ReplayPrivacyConfig } from "./types";
-type ReplayRecordFn = typeof import("rrweb")["record"];
+import type { ReplayPrivacyConfig } from "./types.js";
+type ReplayRecordFn = (typeof import("rrweb"))["record"];
 type ReplayRecordOptions = NonNullable<Parameters<ReplayRecordFn>[0]>;
 type ReplayEmit = NonNullable<ReplayRecordOptions["emit"]>;
 type ReplayEvent = Parameters<ReplayEmit>[0];
@@ -13,4 +13,3 @@ export declare function buildReplayRecordOptions(input: {
 }): ReplayPrivacyRecordOptions;
 export declare function applyReplayEventPrivacy<T extends ReplayEvent>(event: T, privacy?: ReplayPrivacyConfig): T;
 export {};
-//# sourceMappingURL=replay-privacy.d.ts.map

package/dist/replay-privacy.js CHANGED Viewed

@@ -7,9 +7,16 @@ const MASKED_TEXT_KEYS = new Set([
     "title",
     "value",
 ]);
+// Force rrweb to emit a fresh Meta+FullSnapshot every minute. Without this,
+// only the first segment of a session contains a snapshot, so any later
+// segment loss (or seeking to a non-zero anchor) leaves the player with
+// nothing to render. 60s matches Sentry's buffer-mode checkout cadence and
+// keeps each segment independently seekable.
+const CHECKOUT_EVERY_NMS = 60_000;
 export function buildReplayRecordOptions(input) {
     const options = {
         emit: input.emit,
+        checkoutEveryNms: CHECKOUT_EVERY_NMS,
     };
     if (input.privacy?.blockSelector) {
         options.blockSelector = input.privacy.blockSelector;
@@ -25,36 +32,59 @@ export function applyReplayEventPrivacy(event, privacy) {
     if (!privacy?.maskAllText) {
         return event;
     }
-    return redactReplayValue(event, {
+    redactReplayValue(event, {
         currentTagName: null,
         key: "",
     });
+    return event;
 }
 function redactReplayValue(value, context) {
-    if (typeof value === "string") {
-        return shouldMaskString(context) ? maskReplayText(value) : value;
-    }
     if (Array.isArray(value)) {
-        return value.map((entry) => redactReplayValue(entry, context));
-    }
-    if (!isReplayPrivacyObject(value)) {
-        return value;
+        value.forEach((entry, index) => {
+            if (isString(entry) && shouldMaskString(context)) {
+                value.splice(index, 1, maskReplayText(String(entry)));
+            }
+            else {
+                redactReplayValue(entry, context);
+            }
+        });
+        return;
     }
+    if (!isReplayRecord(value))
+        return;
     const nextTagName = readTagName(value) ?? context.currentTagName;
-    const nextValue = {};
     for (const [entryKey, entryValue] of Object.entries(value)) {
-        nextValue[entryKey] = redactReplayValue(entryValue, {
-            currentTagName: nextTagName,
-            key: entryKey,
-        });
+        const nextContext = { currentTagName: nextTagName, key: entryKey };
+        if (isString(entryValue) && shouldMaskString(nextContext)) {
+            Object.defineProperty(value, entryKey, {
+                configurable: true,
+                enumerable: true,
+                value: maskReplayText(String(entryValue)),
+                writable: true,
+            });
+        }
+        else {
+            redactReplayValue(entryValue, nextContext);
+        }
+    }
+}
+function isReplayRecord(value) {
+    if (value === null)
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(Object(value));
+        return prototype === null || Object.getPrototypeOf(prototype) === null;
+    }
+    catch {
+        return false;
     }
-    return nextValue;
 }
-function isReplayPrivacyObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function isString(value) {
+    return Object.prototype.toString.call(value) === "[object String]";
 }
 function readTagName(value) {
-    return typeof value.tagName === "string" ? value.tagName.toLowerCase() : null;
+    const tagName = Object.getOwnPropertyDescriptor(Object(value), "tagName")?.value;
+    return isString(tagName) ? String(tagName).toLowerCase() : null;
 }
 function maskReplayText(value) {
     return value.replace(/[^\s]/g, "*");

package/dist/replay-retry.d.ts ADDED Viewed

@@ -0,0 +1,40 @@
+interface ReplayUploadClient {
+    url: string;
+    headerKey: string;
+    debug: boolean;
+}
+/**
+ * In-memory retry queue for replay payloads.
+ *
+ * Semantics:
+ * - Enqueue a payload; `flush()` tries to send the oldest pending job.
+ * - Successful 2xx -> drop the job.
+ * - 4xx (except 429) -> drop the job (non-retryable client error).
+ * - 5xx, 429, or network error -> increment attempts; reschedule with
+ *   exponential backoff (1s, 2s, 4s). After MAX_ATTEMPTS, the job is dropped.
+ * - Concurrency: a `sending` flag prevents two concurrent `flush` runs from
+ *   double-sending the same head-of-queue job.
+ * - Queue length is capped at MAX_PENDING_PAYLOADS to bound memory.
+ */
+export declare class ReplayUploader {
+    private readonly client;
+    private readonly queue;
+    private sending;
+    private activeController;
+    private retryTimer;
+    private disposed;
+    constructor(client: ReplayUploadClient);
+    enqueue(body: string): void;
+    /**
+     * Returns every payload body and clears the queue. The active fetch is
+     * aborted first so pagehide can transfer ownership of the head payload to
+     * sendBeacon instead of losing the initial replay snapshot on navigation.
+     */
+    drain(): string[];
+    private oldestDroppableIndex;
+    dispose(): void;
+    flush(): Promise<void>;
+    private scheduleRetry;
+    private send;
+}
+export {};

package/dist/replay-retry.js ADDED Viewed

@@ -0,0 +1,193 @@
+import { attemptAsync } from "./_vendor/result-runtime/attempt.js";
+import { getDefaultHeaders, nextBackoffMs } from "./_vendor/sdk-runtime/runtime/public-sdk-runtime.js";
+const MAX_ATTEMPTS = 3;
+const MAX_BACKOFF_MS = 4_000;
+const MAX_PENDING_PAYLOADS = 10;
+const SDK_NAME = "@squasher-ai/browser";
+const SDK_VERSION = "0.3.0";
+const DEFAULT_TELEMETRY_HEADERS = getDefaultHeaders({
+    packageName: SDK_NAME,
+    packageVersion: SDK_VERSION,
+});
+/**
+ * Compute next-attempt backoff. Delegates the math + Retry-After parsing to
+ * sdk-core's `nextBackoffMs` so every Squasher SDK shares one
+ * implementation. We keep the replay-specific 4-second cap because replay
+ * payloads are bursty and a longer wait throws off the page-unload window.
+ */
+function backoffForAttempt(attempts, headers) {
+    // sdk-core uses 0-indexed attempts; this module uses 1-indexed (1st retry).
+    return Math.round(nextBackoffMs({
+        attempt: attempts - 1,
+        headers: headers ?? undefined,
+        maxSleepMs: MAX_BACKOFF_MS,
+    }));
+}
+/**
+ * In-memory retry queue for replay payloads.
+ *
+ * Semantics:
+ * - Enqueue a payload; `flush()` tries to send the oldest pending job.
+ * - Successful 2xx -> drop the job.
+ * - 4xx (except 429) -> drop the job (non-retryable client error).
+ * - 5xx, 429, or network error -> increment attempts; reschedule with
+ *   exponential backoff (1s, 2s, 4s). After MAX_ATTEMPTS, the job is dropped.
+ * - Concurrency: a `sending` flag prevents two concurrent `flush` runs from
+ *   double-sending the same head-of-queue job.
+ * - Queue length is capped at MAX_PENDING_PAYLOADS to bound memory.
+ */
+export class ReplayUploader {
+    client;
+    queue = [];
+    sending = false;
+    activeController = null;
+    retryTimer = null;
+    disposed = false;
+    constructor(client) {
+        this.client = client;
+    }
+    enqueue(body) {
+        if (this.disposed)
+            return;
+        if (this.queue.length >= MAX_PENDING_PAYLOADS) {
+            if (this.client.debug) {
+                console.warn("[squasher] Replay retry queue full; dropping oldest payload");
+            }
+            this.queue.splice(this.oldestDroppableIndex(), 1);
+        }
+        this.queue.push({ body, attempts: 0 });
+        void this.flush();
+    }
+    /**
+     * Returns every payload body and clears the queue. The active fetch is
+     * aborted first so pagehide can transfer ownership of the head payload to
+     * sendBeacon instead of losing the initial replay snapshot on navigation.
+     */
+    drain() {
+        this.activeController?.abort();
+        this.activeController = null;
+        const bodies = this.queue.map((job) => job.body);
+        this.queue.length = 0;
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+        return bodies;
+    }
+    oldestDroppableIndex() {
+        return this.sending && this.queue.length > 1 ? 1 : 0;
+    }
+    dispose() {
+        this.disposed = true;
+        this.activeController?.abort();
+        this.activeController = null;
+        this.queue.length = 0;
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+    }
+    async flush() {
+        if (this.sending || this.disposed)
+            return;
+        if (this.queue.length === 0)
+            return;
+        if (this.retryTimer)
+            return; // waiting for scheduled retry
+        this.sending = true;
+        try {
+            const job = this.queue[0];
+            if (!job)
+                return;
+            const controller = new AbortController();
+            this.activeController = controller;
+            const outcome = await this.send(job.body, controller.signal);
+            if (this.activeController === controller) {
+                this.activeController = null;
+            }
+            if (this.queue[0] === job) {
+                if (outcome.kind === "success") {
+                    this.queue.shift();
+                }
+                else if (outcome.kind === "drop") {
+                    this.queue.shift();
+                    if (this.client.debug) {
+                        console.warn(`[squasher] Replay upload failed with non-retryable status; dropping payload (${outcome.reason})`);
+                    }
+                }
+                else {
+                    job.attempts += 1;
+                    if (job.attempts >= MAX_ATTEMPTS) {
+                        this.queue.shift();
+                        if (this.client.debug) {
+                            console.warn(`[squasher] Replay upload exhausted ${MAX_ATTEMPTS} attempts; dropping payload`);
+                        }
+                    }
+                    else {
+                        const delay = backoffForAttempt(job.attempts, outcome.retryHeaders);
+                        this.scheduleRetry(delay);
+                        return;
+                    }
+                }
+            }
+        }
+        finally {
+            this.sending = false;
+        }
+        if (this.queue.length > 0 && !this.retryTimer) {
+            void this.flush();
+        }
+    }
+    scheduleRetry(delayMs) {
+        if (this.retryTimer)
+            return;
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            void this.flush();
+        }, delayMs);
+    }
+    async send(body, signal) {
+        const result = await attemptAsync({
+            try: async () => {
+                const response = await fetch(this.client.url, {
+                    method: "POST",
+                    headers: {
+                        ...DEFAULT_TELEMETRY_HEADERS,
+                        "Content-Type": "application/json",
+                        "x-squasher-key": this.client.headerKey,
+                    },
+                    body,
+                    signal,
+                });
+                return response;
+            },
+            catch: ({ cause }) => {
+                if (this.client.debug) {
+                    console.warn("[squasher] Replay upload network error:", cause);
+                }
+                return null;
+            },
+        });
+        if (!result) {
+            return { kind: "retry", retryHeaders: null };
+        }
+        if (result.status >= 200 && result.status < 300) {
+            if (this.client.debug) {
+                console.log("[squasher] Replay events sent via fetch");
+            }
+            return { kind: "success" };
+        }
+        if (result.status === 429) {
+            // Hand the response Headers straight to sdk-core's nextBackoffMs so it
+            // can read Retry-After-Ms or Retry-After (seconds or HTTP-date).
+            return {
+                kind: "retry",
+                retryHeaders: result.headers,
+            };
+        }
+        if (result.status >= 500) {
+            return { kind: "retry", retryHeaders: null };
+        }
+        return { kind: "drop", reason: `HTTP ${result.status}` };
+    }
+}