@scalebun/web 1.0.0

package/dist/features/network/fetchInterceptor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Patches `fetch` to record method/url/status/duration (+ sizes from headers). Bodies are NOT read
+ * (we never consume the stream) — body capture is a later, opt-in enhancement. Self-excludes the
+ * SDK's own ingestion traffic. `target` is injectable so it's unit-testable in node.
+ */
+import type { OnRecord, IsOwnUrl, InjectTrace } from './types';
+type FetchHolder = {
+    fetch: typeof fetch;
+};
+export declare function installFetch(target: FetchHolder, onRecord: OnRecord, isOwnUrl: IsOwnUrl, injectTrace?: InjectTrace): () => void;
+/** Never buffer more than this to inspect/capture a response body (memory guard for huge responses). */
+export declare const RESPONSE_READ_CEILING: number;
+/**
+ * Read a (cloned, stream-safe) response as text, stopping at RESPONSE_READ_CEILING bytes — cancels the
+ * stream once the ceiling is hit so the rest is never buffered. Falls back to `.text()` where the body
+ * stream is unavailable (jsdom/node). Never throws — resolves null on failure.
+ */
+export declare function readCapped(res: Response): Promise<string | null>;
+export {};
+//# sourceMappingURL=fetchInterceptor.d.ts.map

package/dist/features/network/fetchInterceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchInterceptor.d.ts","sourceRoot":"","sources":["../../../src/features/network/fetchInterceptor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG/D,KAAK,WAAW,GAAG;IAAE,KAAK,EAAE,OAAO,KAAK,CAAA;CAAE,CAAC;AAE3C,wBAAgB,YAAY,CAC1B,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,WAAW,CAAC,EAAE,WAAW,GACxB,MAAM,IAAI,CA+EZ;AAED,wGAAwG;AACxG,eAAO,MAAM,qBAAqB,QAAY,CAAC;AAE/C;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA4BtE"}

package/dist/features/network/fetchInterceptor.js

@@ -0,0 +1,158 @@
+/**
+ * Patches `fetch` to record method/url/status/duration (+ sizes from headers). Bodies are NOT read
+ * (we never consume the stream) — body capture is a later, opt-in enhancement. Self-excludes the
+ * SDK's own ingestion traffic. `target` is injectable so it's unit-testable in node.
+ */
+import { requestBodyBytes, contentLengthBytes, perfNow } from './size';
+export function installFetch(target, onRecord, isOwnUrl, injectTrace) {
+    const original = target.fetch;
+    if (typeof original !== 'function')
+        return () => { };
+    target.fetch = async function patchedFetch(input, init) {
+        const url = urlOf(input);
+        const method = methodOf(input, init);
+        // Never record (or loop on) our own egress.
+        if (isOwnUrl(url))
+            return original.call(this, input, init);
+        // P4.3 — inject a W3C traceparent for allowlisted origins (FE→BE correlation handoff).
+        let traceId;
+        let callInit = init;
+        const trace = injectTrace?.(url);
+        if (trace) {
+            traceId = trace.traceId;
+            const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+            headers.set('traceparent', trace.header);
+            callInit = { ...init, headers };
+        }
+        const startedAt = Date.now(); // epoch — for the wire timestamp + ResourceTiming match
+        const t0 = perfNow(); // monotonic — for duration (immune to clock jumps)
+        const reqBody = bodyString(callInit?.body);
+        const rh = reqHeaders(input, callInit); // effective request headers (init or a Request input)
+        try {
+            const res = await original.call(this, input, callInit);
+            // Stream-safe response read: clone BEFORE the host consumes the body (a clone has its own
+            // stream). Lazily read on demand so we never pay the cost unless N2/N4 actually needs it.
+            let cloned = null;
+            try {
+                cloned = typeof res.clone === 'function' ? res.clone() : null;
+            }
+            catch {
+                cloned = null;
+            }
+            onRecord({
+                method,
+                url,
+                status: res.status,
+                startedAt,
+                duration: Math.round(perfNow() - t0),
+                requestSize: requestBodyBytes(callInit?.body) ?? contentLengthBytes(rh?.get?.('content-length')),
+                responseSize: contentLengthBytes(res.headers?.get?.('content-length')),
+                reqBody,
+                reqContentType: rh?.get?.('content-type') ?? undefined,
+                resContentType: res.headers?.get?.('content-type') ?? undefined,
+                // Stream-read capped at a ceiling so a huge text/JSON response is never fully buffered just to
+                // inspect (GraphQL errors[]) or capture (N4) the first few KB. Lazy: only called during enrich.
+                readResponseText: cloned ? () => readCapped(cloned) : undefined,
+                traceId,
+            });
+            return res;
+        }
+        catch (err) {
+            const e = err;
+            // AbortController → DOMException 'AbortError'; init.signal timeouts surface as 'TimeoutError'.
+            const aborted = e?.name === 'AbortError';
+            const timedOut = e?.name === 'TimeoutError';
+            onRecord({
+                method,
+                url,
+                status: 0,
+                startedAt,
+                duration: Math.round(perfNow() - t0),
+                error: e?.message ?? 'network error',
+                aborted,
+                timedOut,
+            });
+            throw err;
+        }
+    };
+    return () => {
+        target.fetch = original;
+    };
+}
+/** Never buffer more than this to inspect/capture a response body (memory guard for huge responses). */
+export const RESPONSE_READ_CEILING = 64 * 1024;
+/**
+ * Read a (cloned, stream-safe) response as text, stopping at RESPONSE_READ_CEILING bytes — cancels the
+ * stream once the ceiling is hit so the rest is never buffered. Falls back to `.text()` where the body
+ * stream is unavailable (jsdom/node). Never throws — resolves null on failure.
+ */
+export async function readCapped(res) {
+    try {
+        const stream = res.body;
+        if (!stream || typeof stream.getReader !== 'function') {
+            const t = await res.text();
+            return t.length > RESPONSE_READ_CEILING ? t.slice(0, RESPONSE_READ_CEILING) : t;
+        }
+        const reader = stream.getReader();
+        const decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : undefined;
+        let out = '';
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value && decoder)
+                out += decoder.decode(value, { stream: true });
+            if (out.length >= RESPONSE_READ_CEILING) {
+                try {
+                    await reader.cancel();
+                }
+                catch {
+                    /* ignore */
+                }
+                return out.slice(0, RESPONSE_READ_CEILING);
+            }
+        }
+        if (decoder)
+            out += decoder.decode(); // flush any trailing multibyte char
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+function urlOf(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.href;
+    return input.url;
+}
+function methodOf(input, init) {
+    const m = init?.method ??
+        (typeof input !== 'string' && !(input instanceof URL) ? input.method : undefined);
+    return (m ?? 'GET').toUpperCase();
+}
+/** The request body as a string when it's a plain string body (URLSearchParams stringifies too). */
+function bodyString(body) {
+    if (typeof body === 'string')
+        return body;
+    if (typeof URLSearchParams !== 'undefined' && body instanceof URLSearchParams)
+        return body.toString();
+    return undefined; // FormData / Blob / ArrayBuffer / streams — not read (binary / would consume)
+}
+/** Effective request headers — `init.headers`, else a `Request` input's headers. Used for the
+ *  content-type allowlist + a content-length size fallback when the body isn't a measurable `init.body`
+ *  (e.g. `fetch(new Request(url, { body }))`). Sync — never consumes the body stream. */
+function reqHeaders(input, init) {
+    try {
+        if (init?.headers)
+            return new Headers(init.headers);
+        if (typeof Request !== 'undefined' && input instanceof Request)
+            return input.headers;
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+//# sourceMappingURL=fetchInterceptor.js.map

package/dist/features/network/fetchInterceptor.js.map

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

package/dist/features/network/intercept/beacon.d.ts

@@ -0,0 +1,14 @@
+/**
+ * N6 — `navigator.sendBeacon` capture (LAZY chunk). Beacons are fire-and-forget POSTs used for
+ * analytics / unload-time telemetry — invisible to fetch/XHR interceptors. We record one `network`
+ * item per call (protocol 'beacon') with the byte size; `sendBeacon` returns a boolean (queued or
+ * not) synchronously, which we map to a success/failure. Self-excludes the SDK's own egress. Patches
+ * `navigator.sendBeacon`; restores on teardown.
+ */
+import type { OnRecord, IsOwnUrl } from '../types';
+type NavHolder = {
+    sendBeacon: typeof navigator.sendBeacon;
+};
+export declare function installBeacon(nav: NavHolder, onRecord: OnRecord, isOwnUrl: IsOwnUrl): () => void;
+export {};
+//# sourceMappingURL=beacon.d.ts.map

package/dist/features/network/intercept/beacon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"beacon.d.ts","sourceRoot":"","sources":["../../../../src/features/network/intercept/beacon.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAc,MAAM,UAAU,CAAC;AAE/D,KAAK,SAAS,GAAG;IAAE,UAAU,EAAE,OAAO,SAAS,CAAC,UAAU,CAAA;CAAE,CAAC;AAgB7D,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CA4BhG"}

package/dist/features/network/intercept/beacon.js

@@ -0,0 +1,56 @@
+/**
+ * N6 — `navigator.sendBeacon` capture (LAZY chunk). Beacons are fire-and-forget POSTs used for
+ * analytics / unload-time telemetry — invisible to fetch/XHR interceptors. We record one `network`
+ * item per call (protocol 'beacon') with the byte size; `sendBeacon` returns a boolean (queued or
+ * not) synchronously, which we map to a success/failure. Self-excludes the SDK's own egress. Patches
+ * `navigator.sendBeacon`; restores on teardown.
+ */
+function beaconSize(data) {
+    try {
+        if (data == null)
+            return 0;
+        if (typeof data === 'string')
+            return data.length;
+        if (typeof Blob !== 'undefined' && data instanceof Blob)
+            return data.size;
+        if (data instanceof ArrayBuffer)
+            return data.byteLength;
+        if (ArrayBuffer.isView(data))
+            return data.byteLength;
+        if (typeof URLSearchParams !== 'undefined' && data instanceof URLSearchParams)
+            return data.toString().length;
+    }
+    catch {
+        /* defensive */
+    }
+    return undefined;
+}
+export function installBeacon(nav, onRecord, isOwnUrl) {
+    const original = nav.sendBeacon;
+    if (typeof original !== 'function')
+        return () => { };
+    nav.sendBeacon = function patchedSendBeacon(url, data) {
+        const urlStr = String(url);
+        if (isOwnUrl(urlStr))
+            return original.call(nav, url, data ?? undefined);
+        const startedAt = Date.now();
+        const queued = original.call(nav, url, data ?? undefined);
+        const c = {
+            protocol: 'beacon',
+            method: 'POST', // sendBeacon always issues a POST
+            url: urlStr,
+            // Beacon gives no status; a false return means the UA refused to queue it (e.g. over quota).
+            status: queued ? undefined : 0,
+            startedAt,
+            duration: Date.now() - startedAt,
+            requestSize: beaconSize(data),
+            error: queued ? undefined : 'beacon not queued',
+        };
+        onRecord(c);
+        return queued;
+    };
+    return () => {
+        nav.sendBeacon = original;
+    };
+}
+//# sourceMappingURL=beacon.js.map

package/dist/features/network/intercept/beacon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beacon.js","sourceRoot":"","sources":["../../../../src/features/network/intercept/beacon.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAMH,SAAS,UAAU,CAAC,IAAiC;IACnD,IAAI,CAAC;QACH,IAAI,IAAI,IAAI,IAAI;YAAE,OAAO,CAAC,CAAC;QAC3B,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC,MAAM,CAAC;QACjD,IAAI,OAAO,IAAI,KAAK,WAAW,IAAI,IAAI,YAAY,IAAI;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC;QAC1E,IAAI,IAAI,YAAY,WAAW;YAAE,OAAO,IAAI,CAAC,UAAU,CAAC;QACxD,IAAI,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,OAAQ,IAAwB,CAAC,UAAU,CAAC;QAC1E,IAAI,OAAO,eAAe,KAAK,WAAW,IAAI,IAAI,YAAY,eAAe;YAAE,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC;IAC/G,CAAC;IAAC,MAAM,CAAC;QACP,eAAe;IACjB,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,GAAc,EAAE,QAAkB,EAAE,QAAkB;IAClF,MAAM,QAAQ,GAAG,GAAG,CAAC,UAAU,CAAC;IAChC,IAAI,OAAO,QAAQ,KAAK,UAAU;QAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;IAEpD,GAAG,CAAC,UAAU,GAAG,SAAS,iBAAiB,CAAgB,GAAiB,EAAE,IAAsB;QAClG,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;QAC3B,IAAI,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,IAAI,SAAS,CAAC,CAAC;QAExE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,IAAI,SAAS,CAAC,CAAC;QAC1D,MAAM,CAAC,GAAe;YACpB,QAAQ,EAAE,QAAQ;YAClB,MAAM,EAAE,MAAM,EAAE,kCAAkC;YAClD,GAAG,EAAE,MAAM;YACX,6FAA6F;YAC7F,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC9B,SAAS;YACT,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS;YAChC,WAAW,EAAE,UAAU,CAAC,IAAI,CAAC;YAC7B,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,mBAAmB;SAChD,CAAC;QACF,QAAQ,CAAC,CAAC,CAAC,CAAC;QACZ,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC;IAEF,OAAO,GAAG,EAAE;QACV,GAAG,CAAC,UAAU,GAAG,QAAQ,CAAC;IAC5B,CAAC,CAAC;AACJ,CAAC"}

package/dist/features/network/intercept/sse.d.ts

@@ -0,0 +1,16 @@
+/**
+ * N3 — Server-Sent-Events (EventSource) lifecycle capture (LAZY chunk). Like WebSocket, an SSE
+ * stream is long-lived: ONE `network` item per connection, settled on close. SSE is receive-only, so
+ * we count received messages + bytes (the `data` payload) and surface connection errors. Patches the
+ * global `EventSource`; restores on teardown. Counters are bounded integers.
+ *
+ * EventSource has no programmatic "close" event — the host calls `.close()`. We patch that to settle,
+ * and also settle on a terminal `error` (readyState CLOSED) so a dropped connection still emits.
+ */
+import type { OnRecord, IsOwnUrl } from '../types';
+type EsHolder = {
+    EventSource: typeof EventSource;
+};
+export declare function installEventSource(target: EsHolder, onRecord: OnRecord, isOwnUrl: IsOwnUrl): () => void;
+export {};
+//# sourceMappingURL=sse.d.ts.map

package/dist/features/network/intercept/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../../src/features/network/intercept/sse.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAc,MAAM,UAAU,CAAC;AAE/D,KAAK,QAAQ,GAAG;IAAE,WAAW,EAAE,OAAO,WAAW,CAAA;CAAE,CAAC;AAEpD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CAkEvG"}

package/dist/features/network/intercept/sse.js

@@ -0,0 +1,74 @@
+/**
+ * N3 — Server-Sent-Events (EventSource) lifecycle capture (LAZY chunk). Like WebSocket, an SSE
+ * stream is long-lived: ONE `network` item per connection, settled on close. SSE is receive-only, so
+ * we count received messages + bytes (the `data` payload) and surface connection errors. Patches the
+ * global `EventSource`; restores on teardown. Counters are bounded integers.
+ *
+ * EventSource has no programmatic "close" event — the host calls `.close()`. We patch that to settle,
+ * and also settle on a terminal `error` (readyState CLOSED) so a dropped connection still emits.
+ */
+export function installEventSource(target, onRecord, isOwnUrl) {
+    const Original = target.EventSource;
+    if (typeof Original !== 'function')
+        return () => { };
+    function PatchedEventSource(url, init) {
+        const es = init !== undefined ? new Original(url, init) : new Original(url);
+        const urlStr = String(url);
+        if (isOwnUrl(urlStr))
+            return es;
+        const startedAt = Date.now();
+        let messagesReceived = 0;
+        let bytesReceived = 0;
+        let errored = false;
+        let settled = false;
+        const settle = () => {
+            if (settled)
+                return;
+            settled = true;
+            const c = {
+                protocol: 'sse',
+                method: 'GET',
+                url: urlStr,
+                status: errored ? 0 : undefined,
+                startedAt,
+                duration: Date.now() - startedAt,
+                error: errored ? 'eventsource error' : undefined,
+                ws: { messagesReceived, bytesReceived, messagesSent: 0, bytesSent: 0 },
+            };
+            onRecord(c);
+        };
+        es.addEventListener('message', (ev) => {
+            messagesReceived++;
+            bytesReceived += typeof ev.data === 'string' ? ev.data.length : 0;
+        });
+        es.addEventListener('error', () => {
+            // EventSource auto-reconnects unless readyState is CLOSED; only settle on a terminal close.
+            if (es.readyState === 2 /* CLOSED */) {
+                errored = true;
+                settle();
+            }
+        });
+        const origClose = es.close.bind(es);
+        es.close = function patchedClose() {
+            settle();
+            return origClose();
+        };
+        return es;
+    }
+    PatchedEventSource.prototype = Original.prototype;
+    try {
+        Object.defineProperties(PatchedEventSource, {
+            CONNECTING: { value: Original.CONNECTING },
+            OPEN: { value: Original.OPEN },
+            CLOSED: { value: Original.CLOSED },
+        });
+    }
+    catch {
+        /* read-only env — skip */
+    }
+    target.EventSource = PatchedEventSource;
+    return () => {
+        target.EventSource = Original;
+    };
+}
+//# sourceMappingURL=sse.js.map

package/dist/features/network/intercept/sse.js.map

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

package/dist/features/network/intercept/streams.d.ts

@@ -0,0 +1,23 @@
+/** N3/N6 — WebSocket + SSE + sendBeacon installers bundled into ONE lazy chunk (loaded when those
+ *  transports are tracked). Keeps the long-lived-stream + beacon code out of the core bundle. */
+import { installWebSocket } from './websocket';
+import { installEventSource } from './sse';
+import { installBeacon } from './beacon';
+import type { OnRecord, IsOwnUrl } from '../types';
+export { installWebSocket, installEventSource, installBeacon };
+/**
+ * Install all enabled stream transports in one call, returning their uninstallers. Keeps the
+ * feature-detection + wiring out of core (it lives here, in the lazy chunk). `win`/`nav` are passed
+ * so the chunk stays test-injectable and SSR-safe.
+ */
+export declare function installStreams(win: {
+    WebSocket?: typeof WebSocket;
+    EventSource?: typeof EventSource;
+}, nav: {
+    sendBeacon?: typeof navigator.sendBeacon;
+} | undefined, onRecord: OnRecord, isOwnUrl: IsOwnUrl, flags: {
+    ws: boolean;
+    sse: boolean;
+    beacon: boolean;
+}): Array<() => void>;
+//# sourceMappingURL=streams.d.ts.map

package/dist/features/network/intercept/streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.d.ts","sourceRoot":"","sources":["../../../../src/features/network/intercept/streams.ts"],"names":[],"mappings":"AAAA;iGACiG;AACjG,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEnD,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;AAE/D;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE;IAAE,SAAS,CAAC,EAAE,OAAO,SAAS,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,WAAW,CAAA;CAAE,EACvE,GAAG,EAAE;IAAE,UAAU,CAAC,EAAE,OAAO,SAAS,CAAC,UAAU,CAAA;CAAE,GAAG,SAAS,EAC7D,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACpD,KAAK,CAAC,MAAM,IAAI,CAAC,CAYnB"}

package/dist/features/network/intercept/streams.js

@@ -0,0 +1,25 @@
+/** N3/N6 — WebSocket + SSE + sendBeacon installers bundled into ONE lazy chunk (loaded when those
+ *  transports are tracked). Keeps the long-lived-stream + beacon code out of the core bundle. */
+import { installWebSocket } from './websocket';
+import { installEventSource } from './sse';
+import { installBeacon } from './beacon';
+export { installWebSocket, installEventSource, installBeacon };
+/**
+ * Install all enabled stream transports in one call, returning their uninstallers. Keeps the
+ * feature-detection + wiring out of core (it lives here, in the lazy chunk). `win`/`nav` are passed
+ * so the chunk stays test-injectable and SSR-safe.
+ */
+export function installStreams(win, nav, onRecord, isOwnUrl, flags) {
+    const u = [];
+    if (flags.ws && typeof win.WebSocket === 'function') {
+        u.push(installWebSocket(win, onRecord, isOwnUrl));
+    }
+    if (flags.sse && typeof win.EventSource === 'function') {
+        u.push(installEventSource(win, onRecord, isOwnUrl));
+    }
+    if (flags.beacon && nav && typeof nav.sendBeacon === 'function') {
+        u.push(installBeacon(nav, onRecord, isOwnUrl));
+    }
+    return u;
+}
+//# sourceMappingURL=streams.js.map

package/dist/features/network/intercept/streams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streams.js","sourceRoot":"","sources":["../../../../src/features/network/intercept/streams.ts"],"names":[],"mappings":"AAAA;iGACiG;AACjG,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,aAAa,EAAE,CAAC;AAE/D;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,GAAuE,EACvE,GAA6D,EAC7D,QAAkB,EAClB,QAAkB,EAClB,KAAqD;IAErD,MAAM,CAAC,GAAsB,EAAE,CAAC;IAChC,IAAI,KAAK,CAAC,EAAE,IAAI,OAAO,GAAG,CAAC,SAAS,KAAK,UAAU,EAAE,CAAC;QACpD,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAsC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;IACvF,CAAC;IACD,IAAI,KAAK,CAAC,GAAG,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QACvD,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAA0C,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;IAC7F,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;QAChE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,GAAkD,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/features/network/intercept/websocket.d.ts

@@ -0,0 +1,14 @@
+/**
+ * N3 — WebSocket lifecycle capture (LAZY chunk). A WebSocket is a long-lived stream, not a
+ * request/response: we emit ONE `network` item per connection, settled on close, carrying message +
+ * byte counters and the close code/reason. Counters are bounded (just integers) so a chatty socket
+ * (10⁴ messages) stays flat in memory. Patches the global `WebSocket` constructor; restores on
+ * teardown. Self-excludes the SDK's own origin (it doesn't open sockets, but defensive).
+ */
+import type { OnRecord, IsOwnUrl } from '../types';
+type WsHolder = {
+    WebSocket: typeof WebSocket;
+};
+export declare function installWebSocket(target: WsHolder, onRecord: OnRecord, isOwnUrl: IsOwnUrl): () => void;
+export {};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/features/network/intercept/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../../src/features/network/intercept/websocket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAc,MAAM,UAAU,CAAC;AAE/D,KAAK,QAAQ,GAAG;IAAE,SAAS,EAAE,OAAO,SAAS,CAAA;CAAE,CAAC;AAchD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI,CA4ErG"}

package/dist/features/network/intercept/websocket.js

@@ -0,0 +1,97 @@
+/**
+ * N3 — WebSocket lifecycle capture (LAZY chunk). A WebSocket is a long-lived stream, not a
+ * request/response: we emit ONE `network` item per connection, settled on close, carrying message +
+ * byte counters and the close code/reason. Counters are bounded (just integers) so a chatty socket
+ * (10⁴ messages) stays flat in memory. Patches the global `WebSocket` constructor; restores on
+ * teardown. Self-excludes the SDK's own origin (it doesn't open sockets, but defensive).
+ */
+function byteLen(data) {
+    try {
+        if (typeof data === 'string')
+            return data.length;
+        if (data instanceof ArrayBuffer)
+            return data.byteLength;
+        if (ArrayBuffer.isView(data))
+            return data.byteLength;
+        if (typeof Blob !== 'undefined' && data instanceof Blob)
+            return data.size;
+    }
+    catch {
+        /* defensive */
+    }
+    return 0;
+}
+export function installWebSocket(target, onRecord, isOwnUrl) {
+    const Original = target.WebSocket;
+    if (typeof Original !== 'function')
+        return () => { };
+    function PatchedWebSocket(url, protocols) {
+        const ws = protocols !== undefined ? new Original(url, protocols) : new Original(url);
+        const urlStr = String(url);
+        if (isOwnUrl(urlStr))
+            return ws;
+        const startedAt = Date.now();
+        let messagesSent = 0;
+        let messagesReceived = 0;
+        let bytesSent = 0;
+        let bytesReceived = 0;
+        let errored = false;
+        let settled = false;
+        const origSend = ws.send.bind(ws);
+        ws.send = function patchedSend(data) {
+            messagesSent++;
+            bytesSent += byteLen(data);
+            return origSend(data);
+        };
+        ws.addEventListener('message', (ev) => {
+            messagesReceived++;
+            bytesReceived += byteLen(ev.data);
+        });
+        ws.addEventListener('error', () => {
+            errored = true;
+        });
+        const settle = (closeCode, closeReason) => {
+            if (settled)
+                return;
+            settled = true;
+            const c = {
+                protocol: 'ws',
+                method: 'GET', // WS upgrade is a GET; keep the field populated for the wire shape
+                url: urlStr,
+                status: errored && closeCode === undefined ? 0 : undefined,
+                startedAt,
+                duration: Date.now() - startedAt,
+                error: errored ? 'websocket error' : undefined,
+                ws: {
+                    messagesSent,
+                    messagesReceived,
+                    bytesSent,
+                    bytesReceived,
+                    ...(closeCode !== undefined ? { closeCode } : {}),
+                    ...(closeReason ? { closeReason } : {}),
+                },
+            };
+            onRecord(c);
+        };
+        ws.addEventListener('close', (ev) => settle(ev.code, ev.reason));
+        return ws;
+    }
+    // Preserve the constructor surface (constants + prototype) some libs/feature-detects read.
+    PatchedWebSocket.prototype = Original.prototype;
+    try {
+        Object.defineProperties(PatchedWebSocket, {
+            CONNECTING: { value: Original.CONNECTING },
+            OPEN: { value: Original.OPEN },
+            CLOSING: { value: Original.CLOSING },
+            CLOSED: { value: Original.CLOSED },
+        });
+    }
+    catch {
+        /* read-only env — skip */
+    }
+    target.WebSocket = PatchedWebSocket;
+    return () => {
+        target.WebSocket = Original;
+    };
+}
+//# sourceMappingURL=websocket.js.map

package/dist/features/network/intercept/websocket.js.map

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

package/dist/features/network/lazy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Heavy/rare network helpers, bundled into LAZY chunks so they stay out of the core bundle (mirrors
+ * features/errors/lazy.ts and the replay engine). Loaded on demand: the GraphQL parser on the first
+ * GraphQL-looking request, the body capturer when captureBodies is on, WS/SSE installers when those
+ * transports are tracked + first used.
+ */
+import { looksLikeGraphql, parseGraphqlRequest, graphqlResponseHasErrors } from './parse/graphql';
+import { type BodyCaptureOptions } from './capture/body';
+import type { NetCapture } from './types';
+export { looksLikeGraphql, parseGraphqlRequest, graphqlResponseHasErrors };
+export interface HttpEnrichOptions {
+    /** Run N2 GraphQL op-awareness (the capture passed the cheap core-side pre-check). */
+    graphql?: boolean;
+    /** N4 body capture options when captureBodies is on; undefined ⇒ skip body capture. */
+    body?: BodyCaptureOptions;
+}
+/**
+ * Single LAZY enrichment pass for an http capture. Reads the (stream-safe, one-shot) response text
+ * AT MOST ONCE and feeds it to both N2 (GraphQL errors[]) and N4 (response body) so the clone isn't
+ * consumed twice. Mutates `c.graphql` / `c.request` / `c.response` in place. Never throws.
+ */
+export declare function enrichHttpCapture(c: NetCapture, opts: HttpEnrichOptions): Promise<void>;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/features/network/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../../src/features/network/lazy.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAClG,OAAO,EAAsC,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,sFAAsF;IACtF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uFAAuF;IACvF,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6C7F"}