@fixback/expo 0.1.0 → 0.3.0

package/dist/breadcrumbs.js

@@ -1,608 +1,46 @@
+"use strict";
 /**
- * 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.
+ * The Expo SDK's **React Native capture instrumentation** — the runtime seams, and
+ * nothing else.
  *
- * 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.
+ * The trace buffer, the crumb builders, the caps and eviction rules, and the
+ * `console` wrapper are all shared with the browser SDK through
+ * `@fixback/sdk-core` (ADR-0028, replacing the file-parallel port ADR-0021
+ * described), so the server and dashboard cannot tell a mobile trace from a web one.
+ * What is left here is genuinely mobile: how to find React Native's globals, and
+ * the `XMLHttpRequest` patch.
  *
- * 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;
+ * Mobile mappings (spec 0004 §D): 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, and URLs are scrubbed as the crumb is
+ * built. The SDK must never throw into the host app, so every hook is wrapped: a
+ * capture failure is swallowed and the original behaviour always runs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalConsole = globalConsole;
+exports.globalXhr = globalXhr;
+exports.instrumentXhr = instrumentXhr;
+exports.instrumentBreadcrumbs = instrumentBreadcrumbs;
+const sdk_core_1 = require("@fixback/sdk-core");
+function noop() {
+    /* nothing installed */
 }
 /** React Native's global `console`, when present. */
-export function globalConsole() {
+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() {
+function globalXhr() {
     const g = globalThis;
     return typeof g.XMLHttpRequest === "function" ? g.XMLHttpRequest : undefined;
 }
+/** Read one XHR response header defensively — `null` when unavailable or on any throw. */
 function safeXhrHeader(xhr, name) {
     try {
         return typeof xhr.getResponseHeader === "function"
@@ -613,6 +51,7 @@ function safeXhrHeader(xhr, name) {
         return null;
     }
 }
+/** Read an XHR's `statusText` defensively — `undefined` when empty or on any throw. */
 function safeXhrStatusText(xhr) {
     try {
         return xhr.statusText || undefined;
@@ -629,7 +68,7 @@ function safeXhrStatusText(xhr) {
  * 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) {
+function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = sdk_core_1.nowMono) {
     if (typeof ctor !== "function")
         return noop;
     const proto = ctor.prototype;
@@ -643,12 +82,12 @@ export function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = defaultMono)
         const meta = this.__fixbackMeta;
         if (meta && !ignoreUrl(meta.url)) {
             const started = mono();
-            const reqSize = trivialBodySize(body);
+            const reqSize = (0, sdk_core_1.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);
+                settled = (0, sdk_core_1.outcomeFromStatus)(this.status || undefined);
             };
             const onError = () => {
                 settled = "network-error";
@@ -661,7 +100,7 @@ export function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = defaultMono)
             };
             const onDone = () => {
                 try {
-                    buffer.add(networkCrumb({
+                    buffer.add((0, sdk_core_1.networkCrumb)({
                         api: "xhr",
                         method: meta.method,
                         url: meta.url,
@@ -669,9 +108,9 @@ export function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = defaultMono)
                         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),
+                        respSize: (0, sdk_core_1.parseContentLength)(safeXhrHeader(this, "content-length")),
+                        contentType: (0, sdk_core_1.contentTypeOf)(safeXhrHeader(this, "content-type")),
+                        outcome: settled ?? (0, sdk_core_1.outcomeFromStatus)(this.status || undefined),
                     }, now()));
                 }
                 catch {
@@ -697,23 +136,23 @@ export function instrumentXhr(buffer, ctor, ignoreUrl, now, mono = defaultMono)
     };
 }
 /**
- * Install the React Native capture hooks — the console wrapper and the XHR
+ * Install the React Native capture hooks — the shared 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 = {}) {
+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 levels = options.consoleLevels ?? sdk_core_1.DEFAULT_CONSOLE_LEVELS;
     const ignoreUrl = options.ignoreUrl ?? (() => false);
     const now = options.now ?? Date.now;
-    const mono = options.mono ?? defaultMono;
+    const mono = options.mono ?? sdk_core_1.nowMono;
     const captureConsole = options.captureConsole !== false;
     const captureNetwork = options.captureNetwork !== false;
     const teardowns = [];
     if (consoleObj && captureConsole) {
-        teardowns.push(instrumentConsole(buffer, consoleObj, levels, now));
+        teardowns.push((0, sdk_core_1.instrumentConsole)(buffer, consoleObj, levels, now));
     }
     if (captureNetwork) {
         teardowns.push(instrumentXhr(buffer, xhr, ignoreUrl, now, mono));
@@ -729,3 +168,4 @@ export function instrumentBreadcrumbs(buffer, options = {}) {
         }
     };
 }
+//# sourceMappingURL=breadcrumbs.js.map