@fixback/expo 0.1.0 → 0.3.0

package/dist/connect.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * The Expo **Connect** flow (ADR-0032) — the React Native half of the round trip whose
+ * pure pieces (URL building, the code exchange, the storage-key format) live in
+ * `@fixback/sdk-core`.
+ *
+ * Where the browser opens the platform's connect page in a popup, Expo opens it in an
+ * **in-app auth session** (`WebBrowser.openAuthSessionAsync`, injected here as
+ * {@link OpenAuthSession}) — the standard mobile pattern: a secure system browser that
+ * shares no cookies with the app, signs the person in, and hands control back when the
+ * page redirects to the app's own `returnUrl` (a custom scheme or a universal link the
+ * host declares once in `init`). The connect page returns the one-time code on that URL's
+ * `?fixback=` query parameter, exactly as the web's redirect fallback does; the SDK reads
+ * it here and exchanges it for a Reporter session.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseReturnCode = parseReturnCode;
+exports.startExpoConnect = startExpoConnect;
+const sdk_core_1 = require("@fixback/sdk-core");
+/**
+ * Read the Connect return code off a returned URL's `?fixback=` parameter, or `null`.
+ * Parsed by hand rather than via `URL`/`URLSearchParams` so it works on every React
+ * Native runtime (Hermes' URL support is partial), the same DOM-free posture as
+ * `@fixback/sdk-core`. Handles the parameter appearing first (`?fixback=`) or later
+ * (`&fixback=`), and stops at the next `&` or `#`.
+ */
+function parseReturnCode(url) {
+    const match = url.match(new RegExp(`[?&]${sdk_core_1.CONNECT_RETURN_PARAM}=([^&#]*)`));
+    if (!match || !match[1])
+        return null;
+    try {
+        const code = decodeURIComponent(match[1]);
+        return code.length > 0 ? code : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Start Connect: open the connect page in an in-app auth session and resolve to the
+ * one-time code it returns via `returnUrl`, or `cancelled`. `returnUrl` is where the
+ * person is sent back — validated server-side against the Project's allowed origins, so
+ * a hostile app cannot redirect the code elsewhere. Never throws: any failure resolves
+ * to `cancelled`, so a Connect problem never surfaces on the host app.
+ */
+async function startExpoConnect(openAuthSession, params) {
+    const url = (0, sdk_core_1.buildConnectUrl)(params.connectUrl, {
+        key: params.key,
+        returnUrl: params.returnUrl,
+    });
+    let result;
+    try {
+        result = await openAuthSession(url, params.returnUrl);
+    }
+    catch {
+        return { kind: "cancelled" };
+    }
+    if (result.type !== "success" || !result.url)
+        return { kind: "cancelled" };
+    const code = parseReturnCode(result.url);
+    return code ? { kind: "code", code } : { kind: "cancelled" };
+}
+//# sourceMappingURL=connect.js.map

package/dist/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["../src/connect.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AAwCH,0CAWC;AASD,4CAiBC;AA3ED,gDAA0E;AA+B1E;;;;;;GAMG;AACH,SAAgB,eAAe,CAAC,GAAW;IACzC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CACrB,IAAI,MAAM,CAAC,OAAO,+BAAoB,WAAW,CAAC,CACnD,CAAC;IACF,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IACrC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IACvC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACI,KAAK,UAAU,gBAAgB,CACpC,eAAgC,EAChC,MAA8D;IAE9D,MAAM,GAAG,GAAG,IAAA,0BAAe,EAAC,MAAM,CAAC,UAAU,EAAE;QAC7C,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS,EAAE,MAAM,CAAC,SAAS;KAC5B,CAAC,CAAC;IACH,IAAI,MAAyB,CAAC;IAC9B,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC;IACxD,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAC/B,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,GAAG;QAAE,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IAC3E,MAAM,IAAI,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACzC,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;AAC/D,CAAC"}

package/dist/error-capture.d.ts

@@ -1,86 +1,35 @@
 /**
- * Automatic error capture on React Native — ADR-0011's model with mobile
- * triggers (spec 0004 §E), ported from `packages/sdk/src/error-capture.ts`.
+ * Automatic error capture on React Native — the **runtime binding** over the shared
+ * state machine (ADR-0011's model with mobile triggers, spec 0004 §E).
  *
- * Uncaught JS errors arrive through `ErrorUtils.setGlobalHandler` — React
- * Native's one global error seam — and become `source: auto`, `Kind = bug`
- * Feedback for the current session's Reporter. The **previous handler is always
- * chained afterwards**, so dev redboxes and other crash reporters keep working.
- * Each firing is deduped by a per-session fingerprint, rate-limited by a
- * token-bucket burst limiter and a per-session cap, scrubbed through the same
- * `beforeSend` choke point as manual reports, and shipped through the same
- * transport (which honours ingest's `429` / `Retry-After` backpressure).
+ * Uncaught JS errors arrive through `ErrorUtils.setGlobalHandler` — React Native's
+ * one global error seam — and become `source: error`, `Kind = bug` Feedback for the
+ * current session's Reporter. The **previous handler is always chained afterwards**,
+ * so dev redboxes and other crash reporters keep working. Occurrence-count flushes
+ * ride `AppState` → `background`/`inactive` (the `pagehide` equivalent). Unhandled
+ * promise rejections have no stable public Hermes hook and are not captured.
+ *
+ * Everything between the seam and the wire — the fingerprint dedup, the burst
+ * limiter, the session cap, the causal error crumb, the `sentCount` rollback, and
+ * the flush — is `@fixback/sdk-core`'s `createAutoCapture` (ADR-0028), identical to
+ * the browser SDK's. This module supplies only what is React Native's: how to find
+ * and chain `ErrorUtils`, how to distil whatever it hands us, how to assemble the
+ * mobile report, and when to flush.
  *
  * Per-firing order: **`canSubmit`/Gate → dedup → rate-limit/cap → `beforeSend`
  * scrub → enqueue Feedback**. The Gate is honoured by construction: the client
- * installs this only when boot returned `canSubmit`. Occurrence-count flushes
- * ride `AppState` → `background`/`inactive` (the `pagehide` equivalent).
- * Unhandled promise rejections have no stable public Hermes hook and are not
- * captured (ADR-0021 "Revisit when").
+ * installs this only when boot returned `canSubmit`.
  *
  * The whole module is defensive — a Fixback problem (or an error thrown while
  * capturing an error) never surfaces in the host app.
  */
-import type { IdentityInputs } from "./boot";
-import { type BreadcrumbBuffer, type Teardown } from "./breadcrumbs";
+import { type BeforeSend, type BreadcrumbBuffer, DEFAULT_BURST_CAPACITY, DEFAULT_BURST_REFILL_MS, DEFAULT_MAX_DISTINCT_AUTO, type ExtractedError, type IdentityInputs, type Teardown } from "@fixback/sdk-core";
 import { type EnvironmentInputs } from "./report";
-import { type BeforeSend } from "./scrub";
 import { type SubmitDeps, type SubmitInput, type SubmitResult } from "./submit";
 export type { Teardown };
-/** Burst limiter capacity — how many auto-reports may fire back-to-back. */
-export declare const DEFAULT_BURST_CAPACITY = 5;
-/** Burst limiter refill — one token returns every this-many ms. */
-export declare const DEFAULT_BURST_REFILL_MS = 2000;
-/** Per-session ceiling on distinct auto-Feedback; beyond it, only a dropped-count. */
-export declare const DEFAULT_MAX_DISTINCT_AUTO = 20;
-/**
- * Collapse the volatile parts of an error message so a changing string doesn't
- * split one bug: UUIDs, URLs, `0x…` and long hex runs, and long digit runs are
- * replaced with stable placeholders. Short numbers and stable text are kept so
- * genuinely distinct bugs stay distinct.
- */
-export declare function normalize(value: string): string;
-/**
- * A dependency-free FNV-1a hash rendered in base-36. It only has to be stable
- * and well-distributed within one session (the client key is a flood guard; the
- * server does canonical cross-session clustering).
- */
-export declare function hashString(input: string): string;
-/**
- * Extract a compact, stable signature of the top frames of a stack: up to
- * {@link FINGERPRINT_FRAME_LIMIT} frames as `function@basename:line:col`,
- * origin and cache-busting query stripped. Returns `""` when there is no
- * usable stack (message-only fallback).
- */
-export declare function extractTopFrames(stack: string | undefined, limit?: number): string;
-/**
- * The per-session fingerprint:
- * `hash(errorType + "|" + normalize(value) + "|" + topFrames)`. Stack frames
- * dominate when present; otherwise it falls back to type + normalized value.
- */
-export declare function computeFingerprint(type: string, value: string, stack?: string): string;
-/** Configuration for {@link TokenBucket}. */
-export interface TokenBucketOptions {
-    readonly capacity: number;
-    readonly refillIntervalMs: number;
-    /** Clock source, injectable for tests. Defaults to `Date.now`. */
-    readonly now?: () => number;
-}
-/**
- * A token bucket: starts full at `capacity`, refills one token every
- * `refillIntervalMs`, and refuses (`take() === false`) when empty. So a fast
- * error loop that dodges dedup with distinct fingerprints still can't
- * machine-gun ingest.
- */
-export declare class TokenBucket {
-    private readonly options;
-    private tokens;
-    private last;
-    private readonly now;
-    constructor(options: TokenBucketOptions);
-    /** Consume a token if one is available (refilling first), else refuse. */
-    take(): boolean;
-}
+export { DEFAULT_BURST_CAPACITY, DEFAULT_BURST_REFILL_MS, DEFAULT_MAX_DISTINCT_AUTO };
+/** Distil whatever `ErrorUtils` handed us into a fingerprint-able shape. */
+export declare function extractGlobalError(error: unknown): ExtractedError;
 /** React Native's global error handler signature. */
 export type GlobalErrorHandler = (error: unknown, isFatal?: boolean) => void;
 /** The `ErrorUtils` surface the capture uses — injectable for tests. */
@@ -101,7 +50,7 @@ export interface AppStateLike {
 /**
  * Injectable collaborators, defaulted to the real implementations.
  *
- * Deliberately screenshot-free: a `source: auto` report on mobile never
+ * Deliberately screenshot-free: a `source: error` report on mobile never
  * attaches a screenshot. The composer's compensating privacy controls —
  * preview and removal by the Reporter — cannot exist on a machine-filed
  * report, and there is no client-side masking on mobile, so an auto
@@ -111,11 +60,6 @@ export interface AppStateLike {
 export interface AutoCaptureDeps {
     readonly submitReport: (apiUrl: string, input: SubmitInput, deps?: SubmitDeps) => Promise<SubmitResult>;
 }
-/** The Reporter's self-provided display name / email — display only. */
-export interface ReporterDisplay {
-    readonly name?: string;
-    readonly email?: string;
-}
 /** Configuration for {@link installErrorCapture}. */
 export interface AutoCaptureConfig {
     readonly apiUrl: string;
@@ -123,9 +67,15 @@ export interface AutoCaptureConfig {
     /** The configured origin, forwarded on every submission (spec 0004 §A). */
     readonly origin: string;
     readonly identity?: IdentityInputs;
-    /** Display-only name/email carried on auto-captured Feedback too. */
-    readonly display?: ReporterDisplay;
     readonly sdkVersion?: string;
+    /**
+     * The host app's **Release** (#117, ADR-0024) — already validated by the client
+     * (`normaliseRelease`). Stamped into every auto report's environment so the
+     * server can symbolicate the captured frames against this build's sourcemaps.
+     */
+    readonly release?: string;
+    /** The deploy environment (`production` / `staging` / …), stamped on every report. */
+    readonly deployEnvironment?: string;
     /** The shared trace buffer; the failing error is added to it before filing. */
     readonly buffer?: BreadcrumbBuffer | null;
     /** Per-project client scrub hook, run at the `beforeSend` choke point. */

package/dist/error-capture.js

@@ -1,207 +1,57 @@
+"use strict";
 /**
- * Automatic error capture on React Native — ADR-0011's model with mobile
- * triggers (spec 0004 §E), ported from `packages/sdk/src/error-capture.ts`.
+ * Automatic error capture on React Native — the **runtime binding** over the shared
+ * state machine (ADR-0011's model with mobile triggers, spec 0004 §E).
  *
- * Uncaught JS errors arrive through `ErrorUtils.setGlobalHandler` — React
- * Native's one global error seam — and become `source: auto`, `Kind = bug`
- * Feedback for the current session's Reporter. The **previous handler is always
- * chained afterwards**, so dev redboxes and other crash reporters keep working.
- * Each firing is deduped by a per-session fingerprint, rate-limited by a
- * token-bucket burst limiter and a per-session cap, scrubbed through the same
- * `beforeSend` choke point as manual reports, and shipped through the same
- * transport (which honours ingest's `429` / `Retry-After` backpressure).
+ * Uncaught JS errors arrive through `ErrorUtils.setGlobalHandler` — React Native's
+ * one global error seam — and become `source: error`, `Kind = bug` Feedback for the
+ * current session's Reporter. The **previous handler is always chained afterwards**,
+ * so dev redboxes and other crash reporters keep working. Occurrence-count flushes
+ * ride `AppState` → `background`/`inactive` (the `pagehide` equivalent). Unhandled
+ * promise rejections have no stable public Hermes hook and are not captured.
+ *
+ * Everything between the seam and the wire — the fingerprint dedup, the burst
+ * limiter, the session cap, the causal error crumb, the `sentCount` rollback, and
+ * the flush — is `@fixback/sdk-core`'s `createAutoCapture` (ADR-0028), identical to
+ * the browser SDK's. This module supplies only what is React Native's: how to find
+ * and chain `ErrorUtils`, how to distil whatever it hands us, how to assemble the
+ * mobile report, and when to flush.
  *
  * Per-firing order: **`canSubmit`/Gate → dedup → rate-limit/cap → `beforeSend`
  * scrub → enqueue Feedback**. The Gate is honoured by construction: the client
- * installs this only when boot returned `canSubmit`. Occurrence-count flushes
- * ride `AppState` → `background`/`inactive` (the `pagehide` equivalent).
- * Unhandled promise rejections have no stable public Hermes hook and are not
- * captured (ADR-0021 "Revisit when").
+ * installs this only when boot returned `canSubmit`.
  *
  * The whole module is defensive — a Fixback problem (or an error thrown while
  * capturing an error) never surfaces in the host app.
  */
-import { errorCrumb, } from "./breadcrumbs";
-import { assembleContent, collectEnvironment, } from "./report";
-import { runBeforeSend } from "./scrub";
-import { submitReport, } from "./submit";
-import { EXPO_SDK_VERSION } from "./version";
-/** Burst limiter capacity — how many auto-reports may fire back-to-back. */
-export const DEFAULT_BURST_CAPACITY = 5;
-/** Burst limiter refill — one token returns every this-many ms. */
-export const DEFAULT_BURST_REFILL_MS = 2_000;
-/** Per-session ceiling on distinct auto-Feedback; beyond it, only a dropped-count. */
-export const DEFAULT_MAX_DISTINCT_AUTO = 20;
-/** How many top stack frames feed the fingerprint. */
-const FINGERPRINT_FRAME_LIMIT = 5;
-/** How many preceding entries an auto-error's causal pointer names. */
-const CAUSED_BY_LIMIT = 5;
-/**
- * The ids of up to the last {@link CAUSED_BY_LIMIT} entries preceding the
- * throw, in time order — the causal pointer an auto-captured error carries so a
- * machine-filed crash names its lead-up. Entries without an id are skipped.
- */
-function precedingIds(entries) {
-    if (!entries || entries.length === 0)
-        return [];
-    const ids = [];
-    for (let i = entries.length - 1; i >= 0 && ids.length < CAUSED_BY_LIMIT; i -= 1) {
-        const id = entries[i]?.id;
-        if (typeof id === "string" && id.length > 0)
-            ids.unshift(id);
-    }
-    return ids;
-}
-// --- Fingerprint (per-session flood-guard key) --------------------------------
-const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
-const URL_RE = /\bhttps?:\/\/[^\s"')]+/gi;
-const HEX_0X_RE = /\b0x[0-9a-f]+\b/gi;
-const HEX_RUN_RE = /\b[0-9a-f]{8,}\b/gi;
-const DIGIT_RUN_RE = /\d{4,}/g;
-/**
- * Collapse the volatile parts of an error message so a changing string doesn't
- * split one bug: UUIDs, URLs, `0x…` and long hex runs, and long digit runs are
- * replaced with stable placeholders. Short numbers and stable text are kept so
- * genuinely distinct bugs stay distinct.
- */
-export function normalize(value) {
-    if (typeof value !== "string" || value.length === 0)
-        return "";
-    return value
-        .replace(UUID_RE, "<uuid>")
-        .replace(URL_RE, "<url>")
-        .replace(HEX_0X_RE, "<hex>")
-        .replace(HEX_RUN_RE, "<hex>")
-        .replace(DIGIT_RUN_RE, "<n>")
-        .trim();
-}
-/**
- * A dependency-free FNV-1a hash rendered in base-36. It only has to be stable
- * and well-distributed within one session (the client key is a flood guard; the
- * server does canonical cross-session clustering).
- */
-export function hashString(input) {
-    let h = 0x811c9dc5;
-    for (let i = 0; i < input.length; i++) {
-        h ^= input.charCodeAt(i);
-        h = Math.imul(h, 0x01000193);
-    }
-    return (h >>> 0).toString(36);
-}
-/** Reduce a frame location to `basename:line:col`, dropping origin and query. */
-function compactLocation(location) {
-    const noQuery = location.replace(/\?[^:]*/, "");
-    const lastSlash = noQuery.lastIndexOf("/");
-    return lastSlash >= 0 ? noQuery.slice(lastSlash + 1) : noQuery;
-}
-/** Parse one stack line into a compact `function@basename:line:col` frame id. */
-function parseFrame(line) {
-    // V8 / Hermes: "at fn (loc)"  |  "at loc"
-    const v8Named = line.match(/^at\s+(.+?)\s+\((.+)\)$/);
-    if (v8Named)
-        return `${v8Named[1] ?? ""}@${compactLocation(v8Named[2] ?? "")}`;
-    const v8Bare = line.match(/^at\s+(.+)$/);
-    if (v8Bare)
-        return `@${compactLocation(v8Bare[1] ?? "")}`;
-    // JSC: "fn@loc"  |  "@loc"
-    const at = line.indexOf("@");
-    if (at >= 0) {
-        const fn = line.slice(0, at);
-        return `${fn}@${compactLocation(line.slice(at + 1))}`;
-    }
-    return null;
-}
-/**
- * Extract a compact, stable signature of the top frames of a stack: up to
- * {@link FINGERPRINT_FRAME_LIMIT} frames as `function@basename:line:col`,
- * origin and cache-busting query stripped. Returns `""` when there is no
- * usable stack (message-only fallback).
- */
-export function extractTopFrames(stack, limit = FINGERPRINT_FRAME_LIMIT) {
-    if (typeof stack !== "string" || stack.length === 0)
-        return "";
-    const frames = [];
-    for (const raw of stack.split("\n")) {
-        const frame = parseFrame(raw.trim());
-        if (frame) {
-            frames.push(frame);
-            if (frames.length >= limit)
-                break;
-        }
-    }
-    return frames.join(" < ");
-}
-/**
- * The per-session fingerprint:
- * `hash(errorType + "|" + normalize(value) + "|" + topFrames)`. Stack frames
- * dominate when present; otherwise it falls back to type + normalized value.
- */
-export function computeFingerprint(type, value, stack) {
-    return hashString(`${type}|${normalize(value)}|${extractTopFrames(stack)}`);
-}
-/**
- * A token bucket: starts full at `capacity`, refills one token every
- * `refillIntervalMs`, and refuses (`take() === false`) when empty. So a fast
- * error loop that dodges dedup with distinct fingerprints still can't
- * machine-gun ingest.
- */
-export class TokenBucket {
-    options;
-    tokens;
-    last;
-    now;
-    constructor(options) {
-        this.options = options;
-        this.now = options.now ?? Date.now;
-        this.tokens = Math.max(0, options.capacity);
-        this.last = this.now();
-    }
-    /** Consume a token if one is available (refilling first), else refuse. */
-    take() {
-        const now = this.now();
-        const { capacity, refillIntervalMs } = this.options;
-        if (refillIntervalMs > 0 && now > this.last) {
-            const refill = Math.floor((now - this.last) / refillIntervalMs);
-            if (refill > 0) {
-                this.tokens = Math.min(capacity, this.tokens + refill);
-                this.last += refill * refillIntervalMs;
-            }
-        }
-        if (this.tokens >= 1) {
-            this.tokens -= 1;
-            return true;
-        }
-        return false;
-    }
-}
-function asString(value) {
-    if (typeof value === "string")
-        return value;
-    if (value == null)
-        return "";
-    try {
-        return String(value);
-    }
-    catch {
-        return "";
-    }
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_DISTINCT_AUTO = exports.DEFAULT_BURST_REFILL_MS = exports.DEFAULT_BURST_CAPACITY = void 0;
+exports.extractGlobalError = extractGlobalError;
+exports.globalErrorUtils = globalErrorUtils;
+exports.installErrorCapture = installErrorCapture;
+const sdk_core_1 = require("@fixback/sdk-core");
+Object.defineProperty(exports, "DEFAULT_BURST_CAPACITY", { enumerable: true, get: function () { return sdk_core_1.DEFAULT_BURST_CAPACITY; } });
+Object.defineProperty(exports, "DEFAULT_BURST_REFILL_MS", { enumerable: true, get: function () { return sdk_core_1.DEFAULT_BURST_REFILL_MS; } });
+Object.defineProperty(exports, "DEFAULT_MAX_DISTINCT_AUTO", { enumerable: true, get: function () { return sdk_core_1.DEFAULT_MAX_DISTINCT_AUTO; } });
+const report_1 = require("./report");
+const submit_1 = require("./submit");
+const version_1 = require("./version");
 /** Distil whatever `ErrorUtils` handed us into a fingerprint-able shape. */
 function extractGlobalError(error) {
     if (error && typeof error === "object") {
         const err = error;
         return {
-            type: asString(err.name) || "Error",
-            value: asString(err.message) || asString(error),
+            type: (0, sdk_core_1.asString)(err.name) || "Error",
+            value: (0, sdk_core_1.asString)(err.message) || (0, sdk_core_1.asString)(error),
             stack: typeof err.stack === "string" ? err.stack : undefined,
             original: error,
         };
     }
-    const value = asString(error);
+    const value = (0, sdk_core_1.asString)(error);
     return { type: "Error", value, original: error ?? value };
 }
 /** React Native's global `ErrorUtils`, when present. */
-export function globalErrorUtils() {
+function globalErrorUtils() {
     const g = globalThis;
     const utils = g.ErrorUtils;
     return utils && typeof utils.setGlobalHandler === "function" ? utils : undefined;
@@ -215,151 +65,82 @@ const NOOP_HANDLE = { destroy: () => { }, droppedCount: () => 0 };
  * Without a usable `ErrorUtils` (no `getGlobalHandler` to restore from) nothing
  * is installed — the SDK never replaces a handler it could not put back.
  */
-export function installErrorCapture(config) {
+function installErrorCapture(config) {
     const errorUtils = config.errorUtils === null ? undefined : config.errorUtils ?? globalErrorUtils();
     if (!errorUtils ||
         typeof errorUtils.setGlobalHandler !== "function" ||
         typeof errorUtils.getGlobalHandler !== "function") {
         return NOOP_HANDLE;
     }
-    const now = config.now ?? Date.now;
-    const sdkVersion = config.sdkVersion ?? EXPO_SDK_VERSION;
-    const maxDistinct = config.maxDistinct ?? DEFAULT_MAX_DISTINCT_AUTO;
-    const submitReportFn = config.deps?.submitReport ?? submitReport;
+    const sdkVersion = config.sdkVersion ?? version_1.EXPO_SDK_VERSION;
+    const submitReportFn = config.deps?.submitReport ?? submit_1.submitReport;
     const readEnvironment = config.environment ?? (() => ({}));
-    const bucket = new TokenBucket({
-        capacity: config.burstCapacity ?? DEFAULT_BURST_CAPACITY,
-        refillIntervalMs: config.burstRefillMs ?? DEFAULT_BURST_REFILL_MS,
-        now,
-    });
-    const seen = new Map();
-    /** Distinct auto-Feedback dropped by the burst limiter or the session cap. */
-    let dropped = 0;
-    /** Build the `source: auto` content for a fingerprint at a given count. */
-    function buildContent(fp, occurrences, opts) {
+    /** Build the `source: error` content for one report. */
+    function buildContent(report) {
         let environment;
         try {
-            environment = collectEnvironment(readEnvironment(), sdkVersion);
+            environment = (0, report_1.collectEnvironment)(readEnvironment(), sdkVersion, config.release);
         }
         catch {
-            environment = collectEnvironment({}, sdkVersion);
+            environment = (0, report_1.collectEnvironment)({}, sdkVersion, config.release);
         }
-        // No Kind rides along (ADR-0023): the server stamps a `source: auto`
+        // No Kind rides along (ADR-0023): the server stamps a `source: error`
         // Issue `bug` deterministically.
-        const base = assembleContent({
+        const base = (0, report_1.assembleContent)({
             url: config.currentUrl?.(),
             environment,
-            trace: opts.trace ? config.buffer?.snapshot() : undefined,
-            reporterName: config.display?.name,
-            reporterEmail: config.display?.email,
+            deployEnvironment: config.deployEnvironment,
+            trace: report.rich ? config.buffer?.snapshot() : undefined,
         });
-        return { ...base, source: "auto", errorSignature: fp, occurrences };
+        return {
+            ...base,
+            source: "error",
+            errorSignature: report.fingerprint,
+            occurrences: report.occurrences,
+            // The structured frames (#117) ride with the rich first report only — a
+            // flush is a light count update, like the trace.
+            ...(report.rich && report.frames.length > 0 ? { errorFrames: report.frames } : {}),
+        };
     }
-    /**
-     * Assemble, scrub, and ship one auto-Feedback (never a screenshot — see
-     * {@link AutoCaptureDeps}). Sets the entry's `sentCount` optimistically so a
-     * concurrent flush never double-sends, and rolls it back on a failed send so
-     * the flush can retry. A `beforeSend` that returns `null` drops the report
-     * without transport.
-     */
-    async function file(fp, occurrences, opts) {
-        const entry = seen.get(fp);
-        if (!entry)
-            return;
-        const previouslySent = entry.sentCount;
-        entry.sentCount = occurrences;
-        try {
-            const draft = buildContent(fp, occurrences, opts);
-            const content = runBeforeSend(draft, {
+    const core = (0, sdk_core_1.createAutoCapture)({
+        extract: extractGlobalError,
+        buffer: config.buffer,
+        burstCapacity: config.burstCapacity,
+        burstRefillMs: config.burstRefillMs,
+        maxDistinct: config.maxDistinct,
+        now: config.now,
+        /**
+         * Assemble, scrub, and ship one auto-Feedback (never a screenshot — see
+         * {@link AutoCaptureDeps}). A `beforeSend` that returns `null` drops the report
+         * without transport, which counts as delivered: there is nothing to retry.
+         */
+        submit: async (report) => {
+            const content = (0, sdk_core_1.runBeforeSend)(buildContent(report), {
                 hook: config.beforeSend,
                 scrub: config.scrub,
             });
             if (!content)
-                return; // dropped at the client scrub choke point — no transport.
-            const result = await submitReportFn(config.apiUrl, {
-                key: config.key,
-                origin: config.origin,
-                identity: config.identity,
-                content,
-                screenshot: null,
-            });
-            if (!result.ok && entry.sentCount === occurrences) {
-                // Held under backpressure, refused, or unreachable — let a flush retry.
-                entry.sentCount = previouslySent;
-            }
-        }
-        catch {
-            if (entry.sentCount === occurrences)
-                entry.sentCount = previouslySent;
-            // The error path must never throw into the host app.
-        }
-    }
-    /** Handle one distilled error: dedup → burst limiter → session cap → file. */
-    function handle(extracted) {
-        const fp = computeFingerprint(extracted.type, extracted.value, extracted.stack);
-        const existing = seen.get(fp);
-        if (existing) {
-            // Dedup: one Feedback per fingerprint per session; count locally.
-            existing.count += 1;
-            existing.lastAt = now();
-            return;
-        }
-        if (!bucket.take()) {
-            dropped += 1; // burst limiter
-            return;
-        }
-        if (seen.size >= maxDistinct) {
-            dropped += 1; // per-session cap — keep only the local dropped-count
-            return;
-        }
-        const at = now();
-        seen.set(fp, { count: 1, firstAt: at, lastAt: at, sentCount: 0 });
-        // The failing error joins the trace so the lead-up and the failure both
-        // show, carrying a causal pointer to the entries preceding the throw.
-        try {
-            const causedBy = precedingIds(config.buffer?.snapshot());
-            config.buffer?.add(errorCrumb(extracted.original, at, causedBy));
-        }
-        catch {
-            /* capture must never throw into the host app */
-        }
-        void file(fp, 1, { trace: true });
-    }
+                return true; // dropped at the client scrub choke point — no transport.
+            const result = await submitReportFn(config.apiUrl, { key: config.key, identity: config.identity, content, screenshot: null }, { origin: config.origin });
+            return result.ok;
+        },
+    });
     const previous = errorUtils.getGlobalHandler() ?? null;
     let destroyed = false;
     const wrapper = (error, isFatal) => {
-        if (!destroyed) {
-            try {
-                handle(extractGlobalError(error));
-            }
-            catch {
-                /* never throw into the host app */
-            }
-        }
+        if (!destroyed)
+            core.capture(error);
         // Always chain the previous handler — redbox in dev, crash reporters, etc.
         if (previous)
             previous(error, isFatal);
     };
     errorUtils.setGlobalHandler(wrapper);
-    /** Flush the final occurrence count of every fingerprint that grew. */
-    const flush = () => {
-        try {
-            for (const [fp, entry] of seen) {
-                if (entry.count > entry.sentCount) {
-                    void file(fp, entry.count, { trace: false });
-                }
-            }
-        }
-        catch {
-            /* best-effort on backgrounding */
-        }
-    };
     let appStateSub = null;
     if (config.appState) {
         try {
             appStateSub = config.appState.addEventListener("change", (state) => {
                 if (state === "background" || state === "inactive")
-                    flush();
+                    core.flush();
             });
         }
         catch {
@@ -390,6 +171,7 @@ export function installErrorCapture(config) {
             }
             appStateSub = null;
         },
-        droppedCount: () => dropped,
+        droppedCount: core.droppedCount,
     };
 }
+//# sourceMappingURL=error-capture.js.map