@fixback/expo 0.1.0

package/dist/breadcrumbs.js

@@ -0,0 +1,731 @@
+/**
+ * The trace **breadcrumb ring buffer** and its React Native capture
+ * instrumentation — a port of `packages/sdk/src/breadcrumbs.ts` kept
+ * file-parallel on purpose (ADR-0021): the entry shapes, stream budgets, caps,
+ * and eviction rules are the web SDK's exactly, so the server and dashboard
+ * cannot tell a mobile trace from a web one.
+ *
+ * Mobile mappings (spec 0004 §D): `console` wrapping is unchanged; network
+ * capture patches `XMLHttpRequest` only — React Native's `fetch` is a polyfill
+ * over XHR, so wrapping both would double-record; navigation crumbs come from
+ * the host app's `trackScreen` calls (there is no `history` to patch); the
+ * masked `ui.*` streams have no mobile source yet and simply never occur.
+ *
+ * Everything private is kept out **at the source**: network crumbs carry method
+ * + URL + status metadata only, **never** bodies; URLs are scrubbed as the
+ * crumb is built. The `beforeSend` choke point (`scrub.ts`) is the final gate.
+ * The SDK must never throw into the host app, so every instrumentation hook is
+ * wrapped: a capture failure is swallowed and the original behaviour always runs.
+ */
+import { scrubUrl } from "./scrub";
+/** Per-stream ring budgets — the web SDK's numbers, unchanged. */
+export const DEFAULT_STREAM_BUDGETS = {
+    network: 100,
+    console: 80,
+    breadcrumbs: 40,
+};
+/** The shared age cap: entries older than this are pruned from every stream. */
+export const DEFAULT_MAX_AGE_MS = 3 * 60 * 1000;
+/** Console levels captured by default: **all** of them. */
+export const DEFAULT_CONSOLE_LEVELS = [
+    "log",
+    "info",
+    "warn",
+    "error",
+    "assert",
+    "debug",
+];
+/**
+ * The console levels **pinned** against eviction: when the console stream
+ * overflows, `warn`/`error`/`assert` are retained ahead of `log`/`info`/`debug`.
+ */
+export const PINNED_CONSOLE_LEVELS = [
+    "warn",
+    "error",
+    "assert",
+];
+function isPinnedConsoleLevel(level) {
+    return level !== undefined && PINNED_CONSOLE_LEVELS.includes(level);
+}
+/**
+ * The console levels for which `source` (`file:line`) is captured — reading a
+ * call site constructs a `new Error()` on every call, so only the levels that
+ * matter for debugging pay that cost. Mirrors {@link PINNED_CONSOLE_LEVELS}.
+ */
+export const SOURCE_CAPTURE_LEVELS = PINNED_CONSOLE_LEVELS;
+function capturesSource(level) {
+    return SOURCE_CAPTURE_LEVELS.includes(level);
+}
+/** Which stream a crumb's category belongs to. */
+export function streamOf(category) {
+    if (category === "console")
+        return "console";
+    if (category === "fetch" || category === "xhr" || category === "beacon") {
+        return "network";
+    }
+    return "breadcrumbs";
+}
+function normalizeBudget(value, fallback) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+/** The default high-res clock: `performance.now()` where available (React Native provides it), else `Date.now`. */
+function defaultMono() {
+    const perf = globalThis.performance;
+    return perf && typeof perf.now === "function" ? perf.now() : Date.now();
+}
+/** A per-buffer id factory: a short random salt + a base-36 sequence. */
+function createIdFactory() {
+    const salt = Math.random().toString(36).slice(2, 8);
+    let seq = 0;
+    return () => `${salt}${(seq++).toString(36)}`;
+}
+/** The streams, in a fixed order for a deterministic merge. */
+const STREAMS = ["network", "console", "breadcrumbs"];
+/**
+ * Trim the **console** stream to its budget with eviction priority:
+ * `warn`/`error`/`assert` are pinned, so the oldest `log`/`info`/`debug`
+ * entries are dropped first; a pinned entry is evicted only when dropping every
+ * low-priority one still leaves the stream over budget (oldest pinned first).
+ */
+function trimConsoleStream(held, budget) {
+    const over = held.length - budget;
+    if (over <= 0)
+        return held;
+    const drop = new Set();
+    for (let i = 0; i < held.length && drop.size < over; i += 1) {
+        if (!isPinnedConsoleLevel(held[i].crumb.level))
+            drop.add(i);
+    }
+    for (let i = 0; i < held.length && drop.size < over; i += 1) {
+        if (!drop.has(i))
+            drop.add(i);
+    }
+    return held.filter((_, i) => !drop.has(i));
+}
+/**
+ * Create the per-stream trace buffer: **three independent FIFO rings** —
+ * `network`, `console`, `breadcrumbs` — each trimmed to its own budget so a
+ * chatty stream never evicts another's lead-up, plus a shared age cap.
+ * `snapshot` merges the three streams into one `mono`-ordered array for
+ * transport — the wire keeps its single `trace` field.
+ */
+export function createBreadcrumbBuffer(config = {}) {
+    const budgets = {
+        network: normalizeBudget(config.budgets?.network, DEFAULT_STREAM_BUDGETS.network),
+        console: normalizeBudget(config.budgets?.console, DEFAULT_STREAM_BUDGETS.console),
+        breadcrumbs: normalizeBudget(config.budgets?.breadcrumbs, DEFAULT_STREAM_BUDGETS.breadcrumbs),
+    };
+    const maxAgeMs = config.maxAgeMs === undefined ? DEFAULT_MAX_AGE_MS : config.maxAgeMs;
+    const beforeBreadcrumb = config.beforeBreadcrumb;
+    const now = config.now ?? Date.now;
+    const mono = config.mono ?? defaultMono;
+    const nextId = config.nextId ?? createIdFactory();
+    const streams = {
+        network: [],
+        console: [],
+        breadcrumbs: [],
+    };
+    let seq = 0;
+    function pruneByAge() {
+        if (typeof maxAgeMs !== "number" || maxAgeMs <= 0)
+            return;
+        const cutoff = now() - maxAgeMs;
+        for (const stream of STREAMS) {
+            const held = streams[stream];
+            if (held.length > 0) {
+                streams[stream] = held.filter((h) => h.crumb.timestamp >= cutoff);
+            }
+        }
+    }
+    return {
+        add(crumb) {
+            let entry = crumb;
+            if (beforeBreadcrumb) {
+                try {
+                    entry = beforeBreadcrumb(crumb);
+                }
+                catch {
+                    // A throwing filter must never break capture; keep the (already
+                    // masked) crumb rather than silently erasing the trace.
+                    entry = crumb;
+                }
+            }
+            if (!entry)
+                return;
+            const stamped = {
+                ...entry,
+                id: entry.id ?? nextId(),
+                timestamp: typeof entry.timestamp === "number" ? entry.timestamp : now(),
+                mono: typeof entry.mono === "number" ? entry.mono : mono(),
+            };
+            const stream = streamOf(stamped.category);
+            streams[stream].push({ crumb: stamped, seq: seq++ });
+            pruneByAge();
+            const held = streams[stream];
+            const budget = budgets[stream];
+            if (held.length > budget) {
+                streams[stream] =
+                    stream === "console"
+                        ? trimConsoleStream(held, budget)
+                        : held.slice(-budget);
+            }
+        },
+        snapshot() {
+            pruneByAge();
+            const merged = [];
+            for (const stream of STREAMS)
+                merged.push(...streams[stream]);
+            merged.sort((a, b) => {
+                const am = typeof a.crumb.mono === "number" ? a.crumb.mono : a.crumb.timestamp;
+                const bm = typeof b.crumb.mono === "number" ? b.crumb.mono : b.crumb.timestamp;
+                return am - bm || a.seq - b.seq;
+            });
+            return merged.map((h) => h.crumb);
+        },
+        clear() {
+            streams.network = [];
+            streams.console = [];
+            streams.breadcrumbs = [];
+            seq = 0;
+        },
+    };
+}
+// --- Pure crumb builders -----------------------------------------------------
+/** Longest crumb message kept; a huge log line is truncated, never dropped. */
+const MAX_MESSAGE_LENGTH = 300;
+/** Longest scrubbed URL kept on a crumb. */
+export const MAX_URL_LENGTH = 2048;
+/** Structured console argument caps, all applied at assembly. */
+export const MAX_ARG_DEPTH = 4;
+export const MAX_ARG_ITEMS = 100;
+export const MAX_ARG_STRING_LENGTH = 1024;
+export const MAX_CONSOLE_ARGS_BYTES = 4096;
+/** Longest Error `stack` kept on a structured `error` arg. */
+const MAX_ERROR_STACK_LENGTH = 2048;
+function capLength(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
+function stringifyArg(arg) {
+    if (typeof arg === "string")
+        return arg;
+    if (arg instanceof Error)
+        return `${arg.name}: ${arg.message}`;
+    if (arg === null || arg === undefined)
+        return String(arg);
+    if (typeof arg === "number" || typeof arg === "boolean")
+        return String(arg);
+    try {
+        return JSON.stringify(arg) ?? String(arg);
+    }
+    catch {
+        return "[object]";
+    }
+}
+function joinArgs(args) {
+    const text = args.map(stringifyArg).join(" ");
+    return text.length > MAX_MESSAGE_LENGTH
+        ? `${text.slice(0, MAX_MESSAGE_LENGTH)}…`
+        : text;
+}
+/** An Error rendered to a structured, size-capped `{ name, message, stack? }`. */
+function describeErrorValue(error) {
+    const out = {
+        name: error.name || "Error",
+        message: capLength(String(error.message ?? ""), MAX_ARG_STRING_LENGTH),
+    };
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+        out.stack = capLength(error.stack, MAX_ERROR_STACK_LENGTH);
+    }
+    return out;
+}
+/**
+ * Build a JSON-safe, depth-/breadth-/string-capped clone of a value for a
+ * `json` console argument. Circular references become `"[Circular]"`; exotic
+ * values are rendered to safe text — always serializable and bounded.
+ */
+function safeCloneValue(value, depth, seen) {
+    if (value === null)
+        return null;
+    const type = typeof value;
+    if (type === "string")
+        return capLength(value, MAX_ARG_STRING_LENGTH);
+    if (type === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (type === "boolean")
+        return value;
+    if (type === "bigint")
+        return `${value.toString()}n`;
+    if (type === "symbol")
+        return value.toString();
+    if (type === "function")
+        return "[Function]";
+    if (type === "undefined")
+        return null;
+    const obj = value;
+    if (value instanceof Error) {
+        const { name, message } = describeErrorValue(value);
+        return { name, message };
+    }
+    if (seen.has(obj))
+        return "[Circular]";
+    if (depth <= 0)
+        return Array.isArray(value) ? "[Array]" : "[Object]";
+    seen.add(obj);
+    try {
+        if (Array.isArray(value)) {
+            const items = value
+                .slice(0, MAX_ARG_ITEMS)
+                .map((item) => safeCloneValue(item, depth - 1, seen));
+            if (value.length > MAX_ARG_ITEMS) {
+                items.push(`… ${value.length - MAX_ARG_ITEMS} more`);
+            }
+            return items;
+        }
+        const source = value;
+        const keys = Object.keys(source);
+        const out = {};
+        for (const key of keys.slice(0, MAX_ARG_ITEMS)) {
+            const child = source[key];
+            if (typeof child === "undefined" || typeof child === "function")
+                continue;
+            out[key] = safeCloneValue(child, depth - 1, seen);
+        }
+        if (keys.length > MAX_ARG_ITEMS)
+            out["…"] = `${keys.length - MAX_ARG_ITEMS} more`;
+        return out;
+    }
+    finally {
+        seen.delete(obj);
+    }
+}
+/** Classify one console argument into a type-tagged {@link ConsoleArg}. */
+export function toConsoleArg(value) {
+    if (value === null || value === undefined)
+        return { t: "null", v: null };
+    const type = typeof value;
+    if (type === "string") {
+        return { t: "string", v: capLength(value, MAX_ARG_STRING_LENGTH) };
+    }
+    if (type === "number") {
+        return Number.isFinite(value)
+            ? { t: "number", v: value }
+            : { t: "string", v: String(value) };
+    }
+    if (type === "boolean")
+        return { t: "bool", v: value };
+    if (type === "bigint")
+        return { t: "string", v: `${value.toString()}n` };
+    if (type === "symbol")
+        return { t: "string", v: value.toString() };
+    if (type === "function")
+        return { t: "string", v: "[Function]" };
+    if (value instanceof Error)
+        return { t: "error", v: describeErrorValue(value) };
+    return { t: "json", v: safeCloneValue(value, MAX_ARG_DEPTH, new Set()) };
+}
+/** The serialized UTF-8 byte length of a value; `Infinity` when it cannot serialize. */
+function serializedBytes(value) {
+    try {
+        const json = JSON.stringify(value) ?? "";
+        const Encoder = globalThis
+            .TextEncoder;
+        return Encoder ? new Encoder().encode(json).length : json.length;
+    }
+    catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+/**
+ * Cap an entry's structured args to {@link MAX_CONSOLE_ARGS_BYTES}: drop
+ * trailing args until the array fits; if even a single arg is over budget, keep
+ * one honest placeholder rather than an unbounded value.
+ */
+function capConsoleArgs(args) {
+    if (serializedBytes(args) <= MAX_CONSOLE_ARGS_BYTES)
+        return args;
+    let out = args.slice();
+    while (out.length > 1 && serializedBytes(out) > MAX_CONSOLE_ARGS_BYTES) {
+        out = out.slice(0, -1);
+    }
+    if (out.length === 1 && serializedBytes(out) > MAX_CONSOLE_ARGS_BYTES) {
+        return [{ t: "string", v: "[trace: console argument omitted (too large)]" }];
+    }
+    return out;
+}
+/**
+ * A `console` crumb from a captured call's level and arguments. The `message`
+ * is the one-line preview; `args` preserves each argument as a structured,
+ * type-tagged, size-capped value; `source` is the best-effort `file:line`.
+ */
+export function consoleCrumb(level, args, timestamp, source) {
+    const structured = capConsoleArgs(args.map(toConsoleArg));
+    const crumb = {
+        category: "console",
+        level,
+        message: joinArgs(args),
+        timestamp,
+        ...(structured.length > 0 ? { args: structured } : {}),
+        ...(source ? { source } : {}),
+    };
+    return crumb;
+}
+/**
+ * A `navigation` crumb; both sides are scrubbed and length-capped as the crumb
+ * is built. On mobile this is fed by `trackScreen` (spec 0004 §D) — the values
+ * are screen URLs derived from the configured origin.
+ */
+export function navigationCrumb(from, to, timestamp) {
+    const fromUrl = capLength(scrubUrl(from), MAX_URL_LENGTH);
+    const toUrl = capLength(scrubUrl(to), MAX_URL_LENGTH);
+    return {
+        category: "navigation",
+        message: `${fromUrl} → ${toUrl}`,
+        timestamp,
+        data: { from: fromUrl, to: toUrl },
+    };
+}
+/** Classify an HTTP status into a {@link NetworkOutcome}. */
+export function outcomeFromStatus(status) {
+    if (typeof status !== "number" || status <= 0)
+        return "network-error";
+    if (status >= 500)
+        return "http-5xx";
+    if (status >= 400)
+        return "http-4xx";
+    return "ok";
+}
+/**
+ * The trivially-known byte size of a request body — a string's UTF-8 length, a
+ * `Blob`'s `.size`, or an `ArrayBuffer`/typed-array `.byteLength`. Anything
+ * that would require **reading** the body returns `undefined`.
+ */
+export function trivialBodySize(body) {
+    if (typeof body === "string")
+        return utf8ByteLength(body);
+    const BlobCtor = globalThis.Blob;
+    if (BlobCtor && body instanceof BlobCtor)
+        return body.size;
+    if (typeof ArrayBuffer !== "undefined") {
+        if (body instanceof ArrayBuffer)
+            return body.byteLength;
+        if (ArrayBuffer.isView(body))
+            return body.byteLength;
+    }
+    return undefined;
+}
+function utf8ByteLength(value) {
+    try {
+        const Encoder = globalThis
+            .TextEncoder;
+        return Encoder ? new Encoder().encode(value).length : value.length;
+    }
+    catch {
+        return value.length;
+    }
+}
+/** Parse a `content-length` header into a non-negative byte count, or `undefined`. */
+export function parseContentLength(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const bytes = Number.parseInt(value, 10);
+    return Number.isFinite(bytes) && bytes >= 0 ? bytes : undefined;
+}
+/** The media type from a `content-type` header (before any `;` parameters). */
+export function contentTypeOf(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return undefined;
+    const media = value.split(";")[0]?.trim();
+    return media && media.length > 0 ? media : undefined;
+}
+/**
+ * A network crumb with the rich, metadata-only fields the Network tab renders.
+ * The URL is scrubbed and length-capped at assembly. The shape has **no field
+ * for a request/response body or an arbitrary header**.
+ */
+export function networkCrumb(input, timestamp) {
+    const url = capLength(scrubUrl(input.url), MAX_URL_LENGTH);
+    const hasStatus = typeof input.status === "number" && input.status > 0;
+    const statusPart = hasStatus ? ` → ${input.status}` : "";
+    const outcomePart = input.outcome !== "ok" ? ` (${input.outcome})` : "";
+    return {
+        category: input.api,
+        api: input.api,
+        method: input.method,
+        url,
+        message: `${input.method} ${url}${statusPart}${outcomePart}`,
+        timestamp,
+        ...(hasStatus ? { status: input.status } : {}),
+        ...(input.statusText ? { statusText: input.statusText } : {}),
+        ...(typeof input.durationMs === "number" ? { durationMs: input.durationMs } : {}),
+        ...(typeof input.reqSize === "number" ? { reqSize: input.reqSize } : {}),
+        ...(typeof input.respSize === "number" ? { respSize: input.respSize } : {}),
+        ...(input.contentType ? { contentType: input.contentType } : {}),
+        outcome: input.outcome,
+    };
+}
+/** A thin `xhr` crumb from method + URL + status (outcome derived from the status). */
+export function xhrCrumb(method, url, status, timestamp) {
+    return networkCrumb({ api: "xhr", method, url, status, outcome: outcomeFromStatus(status) }, timestamp);
+}
+function describeError(error) {
+    if (error instanceof Error) {
+        return { name: error.name || "Error", message: error.message };
+    }
+    if (typeof error === "string")
+        return { name: "Error", message: error };
+    return { name: "Error", message: stringifyArg(error) };
+}
+/**
+ * An `error` crumb for the failing exception that ends the trace. When
+ * `causedBy` is given (an auto-captured error), it rides on the crumb as the
+ * causal pointer to the ids of the entries immediately preceding the throw.
+ */
+export function errorCrumb(error, timestamp, causedBy) {
+    const { name, message } = describeError(error);
+    const crumb = {
+        category: "error",
+        level: "error",
+        message: message ? `${name}: ${message}` : name,
+        timestamp,
+        data: { errorType: name },
+    };
+    return causedBy && causedBy.length > 0 ? { ...crumb, causedBy } : crumb;
+}
+/** React Native's global `console`, when present. */
+export function globalConsole() {
+    const g = globalThis;
+    return g.console && typeof g.console === "object" ? g.console : undefined;
+}
+function noop() {
+    /* nothing installed */
+}
+/**
+ * Parse a single stack line into a `{ file, line }` location, or `undefined`.
+ * Handles V8/Hermes (`at fn (file:line:col)` / `at file:line:col`) and
+ * JSC (`fn@file:line:col`) frames; a query string on the asset URL is dropped.
+ */
+function parseStackFrame(line) {
+    let loc;
+    const v8Named = line.match(/^at\s+.+?\s+\((.+)\)$/);
+    if (v8Named) {
+        loc = v8Named[1];
+    }
+    else {
+        const v8Bare = line.match(/^at\s+(.+)$/);
+        if (v8Bare) {
+            loc = v8Bare[1];
+        }
+        else {
+            const at = line.indexOf("@");
+            if (at >= 0)
+                loc = line.slice(at + 1);
+        }
+    }
+    if (!loc)
+        return undefined;
+    loc = loc.replace(/\?[^:]*/, "");
+    const m = loc.match(/^(.*):(\d+):\d+$/) ?? loc.match(/^(.*):(\d+)$/);
+    if (!m)
+        return undefined;
+    const file = m[1] ?? "";
+    const lineNo = Number(m[2]);
+    if (!file || !Number.isFinite(lineNo))
+        return undefined;
+    return { file, line: lineNo };
+}
+/**
+ * The best-effort `file:line` a console call was made from. Parses the frames
+ * of a stack, skipping `skipFrames` leading (SDK-internal) frames so the
+ * source points at the host code that called `console.*`.
+ */
+export function sourceFromStack(stack, skipFrames = 0) {
+    if (typeof stack !== "string" || stack.length === 0)
+        return undefined;
+    const frames = [];
+    for (const raw of stack.split("\n")) {
+        const frame = parseStackFrame(raw.trim());
+        if (frame)
+            frames.push(frame);
+    }
+    return frames[skipFrames];
+}
+/** Frames between `new Error()` (inside the console wrapper) and the host caller. */
+const CONSOLE_SOURCE_SKIP_FRAMES = 1;
+/** Wrap `console` methods so calls at the captured levels become crumbs. */
+export function instrumentConsole(buffer, consoleObj, levels, now) {
+    const restores = [];
+    for (const level of levels) {
+        const original = consoleObj[level];
+        if (typeof original !== "function")
+            continue;
+        const withSource = capturesSource(level);
+        const wrapper = (...args) => {
+            let source;
+            if (withSource) {
+                try {
+                    source = sourceFromStack(new Error().stack, CONSOLE_SOURCE_SKIP_FRAMES);
+                }
+                catch {
+                    source = undefined;
+                }
+            }
+            try {
+                if (level === "assert") {
+                    // console.assert records only when the asserted condition is falsy.
+                    if (!args[0]) {
+                        buffer.add(consoleCrumb("assert", args.slice(1), now(), source));
+                    }
+                }
+                else {
+                    buffer.add(consoleCrumb(level, args, now(), source));
+                }
+            }
+            catch {
+                // Capture must never throw into the host app.
+            }
+            return original.apply(consoleObj, args);
+        };
+        consoleObj[level] = wrapper;
+        restores.push(() => {
+            consoleObj[level] = original;
+        });
+    }
+    return () => {
+        for (const restore of restores)
+            restore();
+    };
+}
+/** React Native's global `XMLHttpRequest`, when present. */
+export function globalXhr() {
+    const g = globalThis;
+    return typeof g.XMLHttpRequest === "function" ? g.XMLHttpRequest : undefined;
+}
+function safeXhrHeader(xhr, name) {
+    try {
+        return typeof xhr.getResponseHeader === "function"
+            ? xhr.getResponseHeader(name)
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function safeXhrStatusText(xhr) {
+    try {
+        return xhr.statusText || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Patch `XMLHttpRequest` to record a rich network crumb when a request settles.
+ * On React Native this is the **single** network hook: the built-in `fetch` is
+ * a polyfill over XHR, so its traffic is captured here too (as `xhr` crumbs)
+ * and `fetch` itself is deliberately not wrapped — wrapping both would record
+ * every request twice (spec 0004 §D). The `send` body argument is **never read
+ * for content** — only its trivially-known size.
+ */
+export function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = defaultMono) {
+    if (typeof ctor !== "function")
+        return noop;
+    const proto = ctor.prototype;
+    const originalOpen = proto.open;
+    const originalSend = proto.send;
+    proto.open = function (method, url, ...rest) {
+        this.__fixbackMeta = { method: String(method).toUpperCase(), url: String(url) };
+        return originalOpen.call(this, method, url, ...rest);
+    };
+    proto.send = function (body) {
+        const meta = this.__fixbackMeta;
+        if (meta && !ignoreUrl(meta.url)) {
+            const started = mono();
+            const reqSize = trivialBodySize(body);
+            // The terminal event names the outcome; `loadend` always follows exactly
+            // one of load/error/timeout/abort, so by record time `settled` is set.
+            let settled;
+            const onLoad = () => {
+                settled = outcomeFromStatus(this.status || undefined);
+            };
+            const onError = () => {
+                settled = "network-error";
+            };
+            const onTimeout = () => {
+                settled = "timeout";
+            };
+            const onAbort = () => {
+                settled = "aborted";
+            };
+            const onDone = () => {
+                try {
+                    buffer.add(networkCrumb({
+                        api: "xhr",
+                        method: meta.method,
+                        url: meta.url,
+                        status: this.status || undefined,
+                        statusText: safeXhrStatusText(this),
+                        durationMs: Math.max(0, mono() - started),
+                        reqSize,
+                        respSize: parseContentLength(safeXhrHeader(this, "content-length")),
+                        contentType: contentTypeOf(safeXhrHeader(this, "content-type")),
+                        outcome: settled ?? outcomeFromStatus(this.status || undefined),
+                    }, now()));
+                }
+                catch {
+                    /* never throw into the host app */
+                }
+                this.removeEventListener("load", onLoad);
+                this.removeEventListener("error", onError);
+                this.removeEventListener("timeout", onTimeout);
+                this.removeEventListener("abort", onAbort);
+                this.removeEventListener("loadend", onDone);
+            };
+            this.addEventListener("load", onLoad);
+            this.addEventListener("error", onError);
+            this.addEventListener("timeout", onTimeout);
+            this.addEventListener("abort", onAbort);
+            this.addEventListener("loadend", onDone);
+        }
+        return originalSend.call(this, body);
+    };
+    return () => {
+        proto.open = originalOpen;
+        proto.send = originalSend;
+    };
+}
+/**
+ * Install the React Native capture hooks — the console wrapper and the XHR
+ * patch — and return a single teardown that removes them all. Each hook is
+ * independent and defensive: a failure in one never blocks the other, and none
+ * can throw into the host app. An off stream is never instrumented at all.
+ */
+export function instrumentBreadcrumbs(buffer, options = {}) {
+    const consoleObj = options.consoleObj === null ? undefined : options.consoleObj ?? globalConsole();
+    const xhr = options.xhr === null ? undefined : options.xhr ?? globalXhr();
+    const levels = options.consoleLevels ?? DEFAULT_CONSOLE_LEVELS;
+    const ignoreUrl = options.ignoreUrl ?? (() => false);
+    const now = options.now ?? Date.now;
+    const mono = options.mono ?? defaultMono;
+    const captureConsole = options.captureConsole !== false;
+    const captureNetwork = options.captureNetwork !== false;
+    const teardowns = [];
+    if (consoleObj && captureConsole) {
+        teardowns.push(instrumentConsole(buffer, consoleObj, levels, now));
+    }
+    if (captureNetwork) {
+        teardowns.push(instrumentXhr(buffer, xhr, ignoreUrl, now, mono));
+    }
+    return () => {
+        for (const teardown of teardowns) {
+            try {
+                teardown();
+            }
+            catch {
+                /* teardown is best-effort */
+            }
+        }
+    };
+}