@debugbundle/sdk-react-native 0.1.0

package/dist/client.js

@@ -0,0 +1,328 @@
+import { getNativeModule, degradedNativeState, safeNativeCall } from "./native.js";
+import { defaultRedactFields, DEFAULT_HEADER_ALLOWLIST, sanitizeHeaders, sanitizeValue } from "./redaction.js";
+const SDK_NAME = "@debugbundle/sdk-react-native";
+const DEFAULT_SDK_VERSION = "0.1.0";
+const LOG_LEVELS = {
+    debug: 10,
+    info: 20,
+    warning: 30,
+    error: 40,
+    critical: 50
+};
+export class DebugBundleReactNativeClient {
+    config;
+    nativeModule = null;
+    nativeState = degradedNativeState("not_initialized");
+    context = {};
+    breadcrumbs = [];
+    probeBuffers = new Map();
+    jsProbeActivationExpiresAt = 0;
+    sessionSampledIn = true;
+    sessionEventCount = 0;
+    constructor(config = {}) {
+        this.config = resolveConfig(config);
+        if (Object.keys(config).length > 0) {
+            this.init(config);
+        }
+    }
+    get status() {
+        return this.nativeState.status;
+    }
+    get lastEventAt() {
+        return this.nativeState.lastEventAt ?? null;
+    }
+    init(config) {
+        this.config = resolveConfig(config);
+        this.nativeModule = getNativeModule();
+        this.sessionSampledIn =
+            this.config.enabled &&
+                (this.config.sessionSampleRate >= 1 || Math.random() <= this.config.sessionSampleRate);
+        if (!this.config.enabled) {
+            this.nativeState = { status: "disconnected", lastEventAt: null, nativeModuleAvailable: Boolean(this.nativeModule) };
+            return;
+        }
+        if (!this.config.projectToken || !this.config.endpoint) {
+            this.nativeState = degradedNativeState("missing_project_token_or_endpoint");
+            return;
+        }
+        if (!this.nativeModule) {
+            this.nativeState = degradedNativeState("native_module_unavailable");
+            return;
+        }
+        void safeNativeCall(async () => {
+            this.nativeState = await this.nativeModule.initialize(this.config);
+            if (!this.nativeState.status) {
+                this.nativeState.status = "healthy";
+            }
+        }, undefined);
+        this.nativeState = { status: "healthy", lastEventAt: null, nativeModuleAvailable: true };
+    }
+    captureException(error, context = {}) {
+        const mergedContext = this.mergeContext(context);
+        this.enqueue("frontend_exception", {
+            error: sanitizeValue(error, { redactFields: this.config.redactFields }),
+            context: sanitizeValue(mergedContext, { redactFields: this.config.redactFields }),
+            breadcrumbs: this.breadcrumbs.slice(),
+            probe_data: this.snapshotProbeData()
+        }, stringValue(mergedContext.trace_id), false);
+    }
+    captureError(error, context = {}) {
+        this.captureException(error, context);
+    }
+    captureLog(message, level = "warning", context = {}) {
+        if (!this.config.captureLogs || LOG_LEVELS[level] < LOG_LEVELS[this.config.logLevel]) {
+            return;
+        }
+        this.enqueue("log_event", {
+            level,
+            message: sanitizeValue(message, { redactFields: this.config.redactFields }),
+            context: sanitizeValue(this.mergeContext(context), { redactFields: this.config.redactFields }),
+            source: "javascript"
+        }, stringValue(context.trace_id), true);
+    }
+    captureRequest(request, response, context = {}) {
+        const traceId = request.traceId ?? stringValue(context.trace_id);
+        const payload = {
+            method: request.method,
+            url: sanitizeUrl(request.url),
+            route_template: request.routeTemplate ?? null,
+            request_headers: sanitizeHeaders(request.headers, this.config.headerAllowlist, {
+                redactFields: this.config.redactFields
+            }),
+            response_status: response.statusCode,
+            response_headers: sanitizeHeaders(response.headers, this.config.headerAllowlist, {
+                redactFields: this.config.redactFields
+            }),
+            duration_ms: response.durationMillis ?? null,
+            source: "react-native"
+        };
+        this.recordBreadcrumb("network", payload);
+        if (this.shouldCaptureRequestEvent(response.statusCode)) {
+            this.enqueue("request_event", payload, traceId, true);
+        }
+    }
+    captureMessage(message, level = "warning", context = {}) {
+        this.recordBreadcrumb("message", {
+            level,
+            message: sanitizeValue(message, { redactFields: this.config.redactFields }),
+            context: sanitizeValue(this.mergeContext(context), { redactFields: this.config.redactFields })
+        });
+    }
+    setContext(key, value) {
+        this.context[key] = sanitizeValue(value, { redactFields: this.config.redactFields });
+        if (this.nativeModule?.setContext) {
+            void safeNativeCall(() => this.nativeModule.setContext(key, this.context[key]), undefined);
+        }
+    }
+    probe(label, data, options = {}) {
+        if (!label || this.probeBuffers.size >= this.config.maxProbeLabels && !this.probeBuffers.has(label)) {
+            return;
+        }
+        if (options.heavy && !this.hasActiveJsProbeActivation()) {
+            return;
+        }
+        const value = typeof data === "function" ? safeInvoke(data) : data;
+        const entry = {
+            label,
+            data: sanitizeValue(value, { redactFields: this.config.redactFields }),
+            timestamp: new Date().toISOString(),
+            activation_id: null
+        };
+        const entries = this.probeBuffers.get(label) ?? [];
+        entries.push(entry);
+        this.probeBuffers.set(label, entries.slice(-this.config.maxProbeEntriesPerLabel));
+    }
+    async flush() {
+        if (!this.nativeModule) {
+            return;
+        }
+        await safeNativeCall(async () => {
+            await this.nativeModule.flush();
+            const state = await this.nativeModule.getStatus();
+            this.nativeState = state;
+        }, undefined);
+    }
+    async activateProbeTriggerToken(token) {
+        if (!this.nativeModule?.activateProbeTriggerToken) {
+            return false;
+        }
+        const activated = await safeNativeCall(() => this.nativeModule.activateProbeTriggerToken(token), false);
+        if (activated) {
+            this.jsProbeActivationExpiresAt = Date.now() + 60 * 60 * 1000;
+        }
+        return activated;
+    }
+    recordBreadcrumb(type, data = {}) {
+        this.breadcrumbs.push({
+            breadcrumb_type: type,
+            occurred_at: new Date().toISOString(),
+            data: sanitizeValue(data, { redactFields: this.config.redactFields })
+        });
+        this.breadcrumbs = this.breadcrumbs.slice(-this.config.maxBreadcrumbs);
+    }
+    recordScreen(screenName, previousScreen = null, source = "react-navigation") {
+        if (!this.config.captureScreens) {
+            return;
+        }
+        this.recordBreadcrumb("screen", {
+            screen_name: sanitizeScreenName(screenName),
+            previous_screen: previousScreen ? sanitizeScreenName(previousScreen) : null,
+            source
+        });
+    }
+    enqueue(eventType, payload, traceId, countTowardSession) {
+        if (!this.canCapture(eventType, countTowardSession)) {
+            return;
+        }
+        const event = {
+            schema_version: "1",
+            event_id: generateId(),
+            event_type: eventType,
+            sdk_name: SDK_NAME,
+            sdk_version: this.config.sdkVersion,
+            service: {
+                name: this.config.service,
+                environment: this.config.environment,
+                runtime: "react-native",
+                framework: "react-native"
+            },
+            occurred_at: new Date().toISOString(),
+            correlation: traceId ? { trace_id: traceId } : null,
+            payload,
+            device: this.nativeState.device ?? deviceFromConfig(this.config)
+        };
+        if (countTowardSession) {
+            this.sessionEventCount += 1;
+        }
+        if (!this.nativeModule) {
+            this.nativeState = degradedNativeState("native_module_unavailable");
+            return;
+        }
+        void safeNativeCall(() => this.nativeModule.enqueueEvent(event), undefined);
+    }
+    canCapture(eventType, countTowardSession) {
+        if (!this.config.enabled || !this.config.projectToken || !this.sessionSampledIn) {
+            return false;
+        }
+        if (Math.random() > this.config.sampleRate) {
+            return false;
+        }
+        if (countTowardSession && this.sessionEventCount >= this.config.maxEventsPerSession) {
+            return eventType === "frontend_exception" || eventType === "probe_event";
+        }
+        return true;
+    }
+    mergeContext(context) {
+        return { ...this.context, ...context };
+    }
+    snapshotProbeData() {
+        if (!this.config.probeFlushOnError) {
+            return { version: 1, items: [] };
+        }
+        return {
+            version: 1,
+            items: [...this.probeBuffers.values()].flat()
+        };
+    }
+    hasActiveJsProbeActivation() {
+        return this.jsProbeActivationExpiresAt > Date.now();
+    }
+    shouldCaptureRequestEvent(statusCode) {
+        return statusCode >= 500 || [408, 423, 424, 425, 429].includes(statusCode);
+    }
+}
+export function createDebugBundleClient(config = {}) {
+    return new DebugBundleReactNativeClient(config);
+}
+export function resolveConfig(config) {
+    return {
+        projectToken: config.projectToken ?? "",
+        enabled: config.enabled ?? true,
+        environment: config.environment ?? "production",
+        service: config.service ?? "react-native-app",
+        endpoint: config.endpoint ?? "https://api.debugbundle.com/v1/events",
+        releaseChannel: config.releaseChannel ?? "production",
+        appVersion: config.appVersion ?? null,
+        buildNumber: config.buildNumber ?? null,
+        batchSize: clampInteger(config.batchSize, 10, 1, 100),
+        flushInterval: clampInteger(config.flushInterval, 3000, 100, 60000),
+        sampleRate: clampRate(config.sampleRate),
+        sessionSampleRate: clampRate(config.sessionSampleRate),
+        maxEventsPerSession: clampInteger(config.maxEventsPerSession, 100, 1, 10000),
+        maxBreadcrumbs: clampInteger(config.maxBreadcrumbs, 20, 1, 200),
+        captureErrors: config.captureErrors ?? true,
+        captureUnhandledRejections: config.captureUnhandledRejections ?? true,
+        captureScreens: config.captureScreens ?? true,
+        captureActions: config.captureActions ?? false,
+        captureNetwork: config.captureNetwork ?? true,
+        captureConsole: config.captureConsole ?? false,
+        captureLogs: config.captureLogs ?? true,
+        logLevel: config.logLevel ?? "warning",
+        tracePropagationTargets: config.tracePropagationTargets ?? [],
+        networkFilter: config.networkFilter ?? {},
+        offlineQueueMaxEvents: clampInteger(config.offlineQueueMaxEvents, 500, 1, 10000),
+        offlineQueueMaxBytes: clampInteger(config.offlineQueueMaxBytes, 5 * 1024 * 1024, 1024, 100 * 1024 * 1024),
+        offlineQueueTtl: clampInteger(config.offlineQueueTtl, 72 * 60 * 60 * 1000, 60000, 30 * 24 * 60 * 60 * 1000),
+        requestTimeout: clampInteger(config.requestTimeout, 5000, 100, 60000),
+        maxProbeLabels: clampInteger(config.maxProbeLabels, 50, 1, 500),
+        maxProbeEntriesPerLabel: clampInteger(config.maxProbeEntriesPerLabel, 10, 1, 200),
+        probeFlushOnError: config.probeFlushOnError ?? true,
+        redactFields: config.redactFields ?? defaultRedactFields(),
+        headerAllowlist: config.headerAllowlist ?? DEFAULT_HEADER_ALLOWLIST,
+        sdkVersion: config.sdkVersion ?? DEFAULT_SDK_VERSION
+    };
+}
+function clampInteger(value, fallback, min, max) {
+    if (!Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.min(max, Math.max(min, Math.trunc(value)));
+}
+function clampRate(value) {
+    if (!Number.isFinite(value)) {
+        return 1;
+    }
+    return Math.min(1, Math.max(0, value));
+}
+function safeInvoke(producer) {
+    try {
+        return producer();
+    }
+    catch (error) {
+        return { error: sanitizeValue(error) };
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function sanitizeUrl(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.search = "";
+        return parsed.toString();
+    }
+    catch {
+        return url.split("?")[0] ?? url;
+    }
+}
+function sanitizeScreenName(screenName) {
+    return screenName.replace(/[^a-zA-Z0-9_.:/-]/g, "_").slice(0, 120);
+}
+function generateId() {
+    const cryptoLike = globalThis.crypto;
+    if (cryptoLike?.randomUUID) {
+        return cryptoLike.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (marker) => {
+        const random = Math.trunc(Math.random() * 16);
+        const value = marker === "x" ? random : (random & 0x3) | 0x8;
+        return value.toString(16);
+    });
+}
+function deviceFromConfig(config) {
+    return {
+        app_version: config.appVersion,
+        build_number: config.buildNumber,
+        release_channel: config.releaseChannel
+    };
+}

package/dist/console.d.ts

@@ -0,0 +1,3 @@
+import type { DebugBundleClient } from "./types.js";
+export declare function captureDebugBundleConsole(client: Pick<DebugBundleClient, "captureLog">): () => void;
+//# sourceMappingURL=console.d.ts.map

package/dist/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../src/console.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAuB,MAAM,YAAY,CAAC;AAIzE,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,GAAG,MAAM,IAAI,CAiCnG"}

package/dist/console.js

@@ -0,0 +1,35 @@
+let restoreConsole = null;
+export function captureDebugBundleConsole(client) {
+    if (restoreConsole) {
+        return restoreConsole;
+    }
+    const originalWarn = console.warn;
+    const originalError = console.error;
+    let inCapture = false;
+    console.warn = (...args) => {
+        capture("warning", args);
+        originalWarn(...args);
+    };
+    console.error = (...args) => {
+        capture("error", args);
+        originalError(...args);
+    };
+    restoreConsole = () => {
+        console.warn = originalWarn;
+        console.error = originalError;
+        restoreConsole = null;
+    };
+    return restoreConsole;
+    function capture(level, args) {
+        if (inCapture) {
+            return;
+        }
+        inCapture = true;
+        try {
+            client.captureLog(args.map(String).join(" "), level, { source: "console" });
+        }
+        finally {
+            inCapture = false;
+        }
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+import type { DebugBundleClient } from "./types.js";
+export interface ErrorHandlerInstallOptions {
+    captureUnhandledRejections?: boolean;
+}
+export declare function installDebugBundleErrorHandlers(client: Pick<DebugBundleClient, "captureException">, options?: ErrorHandlerInstallOptions): () => void;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,0BAA0B;IACzC,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC;AAID,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,kBAAkB,CAAC,EACnD,OAAO,GAAE,0BAA+B,GACvC,MAAM,IAAI,CAwCZ"}

package/dist/errors.js

@@ -0,0 +1,42 @@
+let restoreHandlers = null;
+export function installDebugBundleErrorHandlers(client, options = {}) {
+    if (restoreHandlers) {
+        return restoreHandlers;
+    }
+    const restores = [];
+    const errorUtils = globalThis.ErrorUtils;
+    if (errorUtils?.setGlobalHandler) {
+        const previousHandler = errorUtils.getGlobalHandler?.();
+        errorUtils.setGlobalHandler((error, isFatal) => {
+            client.captureException(error, {
+                source: "react-native-global-error",
+                fatal: Boolean(isFatal)
+            });
+            previousHandler?.(error, isFatal);
+        });
+        restores.push(() => {
+            if (previousHandler) {
+                errorUtils.setGlobalHandler?.(previousHandler);
+            }
+        });
+    }
+    if (options.captureUnhandledRejections !== false && hasAddEventListener(globalThis)) {
+        const listener = (event) => {
+            client.captureException(event.reason ?? new Error("Unhandled promise rejection"), {
+                source: "unhandledrejection"
+            });
+        };
+        globalThis.addEventListener("unhandledrejection", listener);
+        restores.push(() => globalThis.removeEventListener("unhandledrejection", listener));
+    }
+    restoreHandlers = () => {
+        for (const restore of restores.reverse()) {
+            restore();
+        }
+        restoreHandlers = null;
+    };
+    return restoreHandlers;
+}
+function hasAddEventListener(value) {
+    return "addEventListener" in value && "removeEventListener" in value;
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { DebugBundleReactNativeClient, createDebugBundleClient } from "./client.js";
+import { captureDebugBundleConsole } from "./console.js";
+import { installDebugBundleErrorHandlers } from "./errors.js";
+import type { DebugBundleCaptureContext, DebugBundleClient, DebugBundleConfig, DebugBundleLogLevel, DebugBundleProbeOptions, DebugBundleRequestInfo, DebugBundleResponseInfo, DebugBundleStatus } from "./types.js";
+export declare const DebugBundle: {
+    init(config: DebugBundleConfig): void;
+    captureException(error: unknown, context?: DebugBundleCaptureContext): void;
+    captureError(error: unknown, context?: DebugBundleCaptureContext): void;
+    captureLog(message: string, level?: DebugBundleLogLevel, context?: DebugBundleCaptureContext): void;
+    captureRequest(request: DebugBundleRequestInfo, response: DebugBundleResponseInfo, context?: DebugBundleCaptureContext): void;
+    captureMessage(message: string, level?: DebugBundleLogLevel, context?: DebugBundleCaptureContext): void;
+    setContext(key: string, value: unknown): void;
+    probe(label: string, data: unknown | (() => unknown), options?: DebugBundleProbeOptions): void;
+    flush(): Promise<void>;
+    activateProbeTriggerToken(token: string): Promise<boolean>;
+    recordBreadcrumb(type: string, data?: Record<string, unknown>): void;
+    recordScreen(screenName: string, previousScreen?: string | null, source?: string): void;
+    readonly status: DebugBundleStatus;
+    readonly lastEventAt: number | null;
+};
+export { createDebugBundleClient, DebugBundleReactNativeClient };
+export { captureDebugBundleConsole };
+export { installDebugBundleErrorHandlers };
+export type { DebugBundleCaptureContext, DebugBundleClient, DebugBundleConfig, DebugBundleLogLevel, DebugBundleProbeOptions, DebugBundleRequestInfo, DebugBundleResponseInfo, DebugBundleStatus };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EACV,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAIpB,eAAO,MAAM,WAAW;iBACT,iBAAiB,GAAG,IAAI;4BAWb,OAAO,YAAY,yBAAyB,GAAG,IAAI;wBAGvD,OAAO,YAAY,yBAAyB,GAAG,IAAI;wBAGnD,MAAM,UAAU,mBAAmB,YAAY,yBAAyB,GAAG,IAAI;4BAG3E,sBAAsB,YAAY,uBAAuB,YAAY,yBAAyB,GAAG,IAAI;4BAGrG,MAAM,UAAU,mBAAmB,YAAY,yBAAyB,GAAG,IAAI;oBAGvF,MAAM,SAAS,OAAO,GAAG,IAAI;iBAGhC,MAAM,QAAQ,OAAO,GAAG,CAAC,MAAM,OAAO,CAAC,YAAY,uBAAuB,GAAG,IAAI;aAGrF,OAAO,CAAC,IAAI,CAAC;qCAGW,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;2BAGnC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;6BAG3C,MAAM,mBAAmB,MAAM,GAAG,IAAI,WAAW,MAAM,GAAG,IAAI;qBAGzE,iBAAiB;0BAGZ,MAAM,GAAG,IAAI;CAGjC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,CAAC;AACjE,OAAO,EAAE,yBAAyB,EAAE,CAAC;AACrC,OAAO,EAAE,+BAA+B,EAAE,CAAC;AAC3C,YAAY,EACV,yBAAyB,EACzB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,iBAAiB,EAClB,CAAC"}

package/dist/index.js

@@ -0,0 +1,59 @@
+import { DebugBundleReactNativeClient, createDebugBundleClient } from "./client.js";
+import { captureDebugBundleConsole } from "./console.js";
+import { installDebugBundleErrorHandlers } from "./errors.js";
+const singleton = new DebugBundleReactNativeClient();
+export const DebugBundle = {
+    init(config) {
+        singleton.init(config);
+        if (config.captureErrors !== false) {
+            installDebugBundleErrorHandlers(singleton, {
+                captureUnhandledRejections: config.captureUnhandledRejections !== false
+            });
+        }
+        if (config.captureConsole === true) {
+            captureDebugBundleConsole(singleton);
+        }
+    },
+    captureException(error, context) {
+        singleton.captureException(error, context);
+    },
+    captureError(error, context) {
+        singleton.captureError(error, context);
+    },
+    captureLog(message, level, context) {
+        singleton.captureLog(message, level, context);
+    },
+    captureRequest(request, response, context) {
+        singleton.captureRequest(request, response, context);
+    },
+    captureMessage(message, level, context) {
+        singleton.captureMessage(message, level, context);
+    },
+    setContext(key, value) {
+        singleton.setContext(key, value);
+    },
+    probe(label, data, options) {
+        singleton.probe(label, data, options);
+    },
+    flush() {
+        return singleton.flush();
+    },
+    activateProbeTriggerToken(token) {
+        return singleton.activateProbeTriggerToken(token);
+    },
+    recordBreadcrumb(type, data) {
+        singleton.recordBreadcrumb(type, data);
+    },
+    recordScreen(screenName, previousScreen, source) {
+        singleton.recordScreen(screenName, previousScreen, source);
+    },
+    get status() {
+        return singleton.status;
+    },
+    get lastEventAt() {
+        return singleton.lastEventAt;
+    }
+};
+export { createDebugBundleClient, DebugBundleReactNativeClient };
+export { captureDebugBundleConsole };
+export { installDebugBundleErrorHandlers };

package/dist/native.d.ts

@@ -0,0 +1,7 @@
+import type { NativeDebugBundleModule, NativeDebugBundleState } from "./types.js";
+export declare function getNativeModule(): NativeDebugBundleModule | null;
+export declare function setNativeModuleForTesting(module: NativeDebugBundleModule | null | undefined): void;
+export declare function degradedNativeState(reason: string): NativeDebugBundleState;
+export declare function safeNativeCall<T>(operation: () => Promise<T> | T, fallback: T): Promise<T>;
+export declare function resetNativeModuleCacheForTesting(): void;
+//# sourceMappingURL=native.d.ts.map

package/dist/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../src/native.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAKlF,wBAAgB,eAAe,IAAI,uBAAuB,GAAG,IAAI,CAgBhE;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAElG;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,CAQ1E;AAED,wBAAsB,cAAc,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMhG;AAED,wBAAgB,gCAAgC,IAAI,IAAI,CAEvD"}

package/dist/native.js

@@ -0,0 +1,59 @@
+let overrideModule;
+let cachedReactNativeModule;
+export function getNativeModule() {
+    if (overrideModule !== undefined) {
+        return overrideModule;
+    }
+    const globalValue = globalThis;
+    if (globalValue.__DebugBundleReactNativeModule) {
+        return globalValue.__DebugBundleReactNativeModule;
+    }
+    if (cachedReactNativeModule !== undefined) {
+        return cachedReactNativeModule;
+    }
+    cachedReactNativeModule = resolveReactNativeModule();
+    return cachedReactNativeModule;
+}
+export function setNativeModuleForTesting(module) {
+    overrideModule = module;
+}
+export function degradedNativeState(reason) {
+    return {
+        status: "degraded",
+        lastEventAt: null,
+        device: null,
+        nativeModuleAvailable: false,
+        degradedReason: reason
+    };
+}
+export async function safeNativeCall(operation, fallback) {
+    try {
+        return await operation();
+    }
+    catch {
+        return fallback;
+    }
+}
+export function resetNativeModuleCacheForTesting() {
+    cachedReactNativeModule = undefined;
+}
+function resolveReactNativeModule() {
+    const required = requireReactNative();
+    const turboModule = required?.TurboModuleRegistry?.get?.("DebugBundleReactNative");
+    if (turboModule) {
+        return turboModule;
+    }
+    return required?.NativeModules?.DebugBundleReactNative ?? null;
+}
+function requireReactNative() {
+    try {
+        const maybeRequire = Function("return typeof require === 'function' ? require : null")();
+        if (!maybeRequire) {
+            return null;
+        }
+        return maybeRequire("react-native");
+    }
+    catch {
+        return null;
+    }
+}

package/dist/navigation.d.ts

@@ -0,0 +1,13 @@
+import type { DebugBundleClient } from "./types.js";
+export interface DebugBundleNavigationRef {
+    current?: unknown;
+    getCurrentRoute?: () => {
+        name?: string;
+        key?: string;
+        params?: unknown;
+    } | undefined;
+}
+export declare function createDebugBundleNavigationRef(): DebugBundleNavigationRef;
+export declare function onDebugBundleNavigationReady(ref: DebugBundleNavigationRef, client?: DebugBundleClient): void;
+export declare function onDebugBundleNavigationStateChange(ref: DebugBundleNavigationRef, client?: DebugBundleClient): void;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../src/navigation.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,WAAW,wBAAwB;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,SAAS,CAAC;CACvF;AAID,wBAAgB,8BAA8B,IAAI,wBAAwB,CAEzE;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,wBAAwB,EAAE,MAAM,GAAE,iBAA+B,GAAG,IAAI,CAKzH;AAED,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,wBAAwB,EAAE,MAAM,GAAE,iBAA+B,GAAG,IAAI,CAO/H"}

package/dist/navigation.js

@@ -0,0 +1,26 @@
+import { DebugBundle } from "./index.js";
+let previousRouteName = null;
+export function createDebugBundleNavigationRef() {
+    return { current: undefined };
+}
+export function onDebugBundleNavigationReady(ref, client = DebugBundle) {
+    previousRouteName = routeName(ref);
+    if (previousRouteName) {
+        client.recordScreen(previousRouteName, null, "react-navigation");
+    }
+}
+export function onDebugBundleNavigationStateChange(ref, client = DebugBundle) {
+    const currentRouteName = routeName(ref);
+    if (!currentRouteName || currentRouteName === previousRouteName) {
+        return;
+    }
+    client.recordScreen(currentRouteName, previousRouteName, "react-navigation");
+    previousRouteName = currentRouteName;
+}
+function routeName(ref) {
+    const route = ref.getCurrentRoute?.();
+    if (!route?.name) {
+        return null;
+    }
+    return route.name.replace(/[^a-zA-Z0-9_.:/-]/g, "_").slice(0, 120);
+}

package/dist/network.d.ts

@@ -0,0 +1,14 @@
+import type { DebugBundleClient, DebugBundleConfig, DebugBundleNetworkFilter } from "./types.js";
+export interface NetworkInstrumentationOptions {
+    client?: DebugBundleClient;
+    tracePropagationTargets?: string[];
+    captureNetwork?: boolean;
+    networkFilter?: DebugBundleNetworkFilter;
+    headerAllowlist?: string[];
+    redactFields?: string[];
+}
+export declare function instrumentDebugBundleNetwork(options?: NetworkInstrumentationOptions): () => void;
+export declare function createInstrumentedFetch(originalFetch: typeof fetch, client: Pick<DebugBundleClient, "captureRequest">, options: NetworkInstrumentationOptions): typeof fetch;
+export declare function shouldInjectTrace(url: string, targets: string[]): boolean;
+export type { DebugBundleConfig };
+//# sourceMappingURL=network.d.ts.map

package/dist/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAMjG,MAAM,WAAW,6BAA6B;IAC5C,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,wBAAwB,CAAC;IACzC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,wBAAgB,4BAA4B,CAAC,OAAO,GAAE,6BAAkC,GAAG,MAAM,IAAI,CAkBpG;AAED,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,OAAO,KAAK,EAC3B,MAAM,EAAE,IAAI,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,EACjD,OAAO,EAAE,6BAA6B,GACrC,OAAO,KAAK,CAgBd;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAKzE;AA+KD,YAAY,EAAE,iBAAiB,EAAE,CAAC"}