@squasher-ai/browser 0.1.0 → 0.2.0

package/dist/index.js

@@ -5,6 +5,7 @@
  *   - Core Web Vitals (LCP, CLS, INP, FCP, TTFB)
  *   - JavaScript errors (window.onerror, unhandledrejection)
  *   - Navigation breadcrumbs, click breadcrumbs, fetch error breadcrumbs
+ *   - Optional console.error events
  *   - Session context for error ↔ vitals correlation
  *
  * Usage:
@@ -21,85 +22,6 @@
  *   // Manual capture:
  *   captureError(new Error('Something went wrong'));
  */
-export { BrowserClient } from "./client";
-// ─── Global singleton ───────────────────────────────────────────────────────
-import { BrowserClient } from "./client";
-let _client = null;
-/** Initialize the global Squasher browser client. Throws if called twice. */
-export function init(config) {
-    if (_client) {
-        throw new Error("squasher.init() called more than once. Call close() first if re-initializing.");
-    }
-    _client = new BrowserClient(config);
-    return _client;
-}
-/** Get the global client (throws if not initialized). */
-export function getClient() {
-    if (!_client) {
-        throw new Error("Squasher not initialized. Call init() first.");
-    }
-    return _client;
-}
-/** Capture an error using the global client. */
-export function captureError(error, extra) {
-    getClient().captureError(error, extra);
-}
-/** Capture a message using the global client. */
-export function captureMessage(message, level) {
-    getClient().captureMessage(message, level);
-}
-/** Capture a generalized telemetry event using the global client. */
-export function captureTelemetry(event) {
-    getClient().captureTelemetry(event);
-}
-/** Track a product analytics event using the global client. */
-export function track(eventName, properties, context) {
-    getClient().track(eventName, properties, context);
-}
-/** Identify a distinct user or visitor using the global client. */
-export function identify(distinctId, traits, context) {
-    getClient().identify(distinctId, traits, context);
-}
-/** Capture a page navigation event using the global client. */
-export function page(name, properties, context) {
-    getClient().page(name, properties, context);
-}
-/** Capture a screen event using the global client. */
-export function screen(name, properties, context) {
-    getClient().screen(name, properties, context);
-}
-/** Capture an agent span using the global client. */
-export function captureSpan(name, context) {
-    getClient().captureSpan(name, context);
-}
-/** Capture a tool call using the global client. */
-export function captureToolCall(name, context) {
-    getClient().captureToolCall(name, context);
-}
-/** Capture an LLM generation event using the global client. */
-export function captureGeneration(message, context) {
-    getClient().captureGeneration(message, context);
-}
-/** Set user context on the global client. */
-export function setUser(user) {
-    getClient().setUser(user);
-}
-/** Set a single tag on the global client. */
-export function setTag(key, value) {
-    getClient().setTag(key, value);
-}
-/** Set multiple tags on the global client. */
-export function setTags(tags) {
-    getClient().setTags(tags);
-}
-/** Add a breadcrumb on the global client. */
-export function addBreadcrumb(crumb) {
-    getClient().addBreadcrumb(crumb);
-}
-/** Close the global client (stop timers, flush vitals, remove handlers). */
-export function close() {
-    if (_client) {
-        _client.close();
-        _client = null;
-    }
-}
+export { BrowserClient } from "./client.js";
+export { addBreadcrumb, captureError, captureGeneration, captureMessage, captureSpan, captureTelemetry, captureToolCall, close, getClient, identify, init, page, screen, setTag, setTags, setUser, track, } from "./runtime/client-singleton.js";
+export { createSpanId, createTraceContext, createTraceId } from "./trace-context.js";

package/dist/next.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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>
+ *     );
+ *   }
+ */
+interface SquasherNextWebVitalsProps {
+    /**
+     * Override the route tag attached to every metric. Defaults to the
+     * current `usePathname()` value, with the pathname re-evaluated lazily
+     * so a single hook subscription doesn't re-fire on every navigation.
+     */
+    path?: string;
+}
+export declare function SquasherNextWebVitals({ path }?: SquasherNextWebVitalsProps): null;
+export {};
+//# sourceMappingURL=next.d.ts.map

package/dist/next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.d.ts","sourceRoot":"","sources":["../src/next.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAeH,UAAU,0BAA0B;IAClC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,qBAAqB,CAAC,EAAE,IAAI,EAAE,GAAE,0BAA+B,QA+B9E"}

package/dist/next.js

@@ -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.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGlE,UAAU,KAAK;IACb,QAAQ,EAAE,SAAS,CAAC;IACpB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;CACxD;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,qBAAsB,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;gBACpD,KAAK,EAAE,KAAK;IAKxB,MAAM,CAAC,wBAAwB,IAAI,KAAK;IAI/B,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAa3D,MAAM,IAAI,SAAS;CAM7B"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAKlE,UAAU,KAAK;IACb,QAAQ,EAAE,SAAS,CAAC;IACpB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;CACxD;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,qBAAsB,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;gBACpD,KAAK,EAAE,KAAK;IAKxB,MAAM,CAAC,wBAAwB,IAAI,KAAK;IAI/B,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI;IAc3D,MAAM,IAAI,SAAS;CAM7B"}

package/dist/react.js

@@ -12,7 +12,8 @@
  *   </SquasherErrorBoundary>
  */
 import { Component } from "react";
-import { getClient } from "./index";
+import { attempt } from "@squasher-ai/result-utils";
+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

@@ -0,0 +1,21 @@
+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;
+//# sourceMappingURL=replay-network.d.ts.map

package/dist/replay-network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-network.d.ts","sourceRoot":"","sources":["../src/replay-network.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,yBAAyB;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,GAAG,UAAU,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,OAAO,CAAC;IACf,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,KAAK,IAAI,CAAC;IAC5E,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAsED,wBAAgB,2BAA2B,CAAC,EAC1C,KAAK,EACL,eAAe,EACf,kBAAuB,EACvB,iBAAiB,GAClB,EAAE,2BAA2B,GAAG,MAAM,IAAI,CA6J1C"}

package/dist/replay-network.js

@@ -0,0 +1,193 @@
+import { attempt, attemptAsync } from "@squasher-ai/result-utils";
+import { readRuntimeNumber, readRuntimeProperty, readRuntimeString } from "@squasher-ai/sdk-core";
+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

@@ -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];

package/dist/replay-privacy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay-privacy.d.ts","sourceRoot":"","sources":["../src/replay-privacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD,KAAK,cAAc,GAAG,cAAc,OAAO,CAAC,CAAC,QAAQ,CAAC,CAAC;AACvD,KAAK,mBAAmB,GAAG,WAAW,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtE,KAAK,UAAU,GAAG,WAAW,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC3D,KAAK,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAc7C,MAAM,MAAM,0BAA0B,GAAG,mBAAmB,GAAG;IAC7D,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAWrD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,GAAG,0BAA0B,CAgB7B;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,WAAW,EAC3D,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,mBAAmB,GAC5B,CAAC,CASH"}
+{"version":3,"file":"replay-privacy.d.ts","sourceRoot":"","sources":["../src/replay-privacy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,KAAK,cAAc,GAAG,CAAC,cAAc,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AACzD,KAAK,mBAAmB,GAAG,WAAW,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtE,KAAK,UAAU,GAAG,WAAW,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;AAC3D,KAAK,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7C,MAAM,MAAM,0BAA0B,GAAG,mBAAmB,GAAG;IAC7D,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAkBrD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE;IAC9C,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,GAAG,0BAA0B,CAiB7B;AAED,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,WAAW,EAC3D,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,mBAAmB,GAC5B,CAAC,CAUH"}

package/dist/replay-privacy.js

@@ -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

@@ -0,0 +1,41 @@
+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 {};
+//# sourceMappingURL=replay-retry.d.ts.map

package/dist/replay-retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-retry.d.ts","sourceRoot":"","sources":["../src/replay-retry.ts"],"names":[],"mappings":"AAmBA,UAAU,kBAAkB;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB;AAmBD;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;IAC5C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyB;IAC/C,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,EAAE,kBAAkB;IAItC,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAY3B;;;;OAIG;IACH,KAAK,IAAI,MAAM,EAAE;IAYjB,OAAO,CAAC,oBAAoB;IAI5B,OAAO,IAAI,IAAI;IAWT,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkD5B,OAAO,CAAC,aAAa;YAQP,IAAI;CAwDnB"}