@scalebun-release/react-native 2.5.0

package/lib/commonjs/features/crash/CrashReporter.js

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DesktopEventSink = exports.CrashReporter = exports.BackendErrorsSink = void 0;
+exports.getCrashReporter = getCrashReporter;
+exports.resetCrashReporter = resetCrashReporter;
+var _crashSafe = require("../../core/lifecycle/crashSafe");
+var _SessionManager = require("../session/SessionManager");
+var _scrubCrash = require("./scrubCrash");
+/**
+ * ScaleBun SDK — Crash Reporter
+ *
+ * Single, central entry point for ALL crash/error reports regardless of origin
+ * (JS uncaught, handled via captureError, or native drained on next launch).
+ *
+ * SOLID:
+ *  - Single Responsibility: normalize a crash report and fan it out to sinks.
+ *  - Open/Closed: add new delivery targets by registering a CrashSink — no
+ *    caller or existing-sink changes required.
+ *  - Liskov/Interface Segregation: every sink implements the same minimal
+ *    `CrashSink` contract (one method).
+ *  - Dependency Inversion: callers depend on the CrashReporter abstraction,
+ *    not on the desktop/backend transports directly.
+ */
+
+/** Where the crash originated. */
+
+/** Normalized, transport-agnostic crash report. */
+
+/**
+ * A delivery target for crash reports. Implementations MUST be no-throw:
+ * a failing sink must never break crash delivery to the other sinks.
+ */
+
+/**
+ * Fans a normalized crash report out to every registered sink.
+ * Sink failures are isolated (noThrow) so one bad target cannot starve others.
+ */
+class CrashReporter {
+  sinks = [];
+
+  /** Register a delivery target. Returns an unsubscribe fn. */
+  registerSink(sink) {
+    this.sinks.push(sink);
+    return () => {
+      const i = this.sinks.indexOf(sink);
+      if (i >= 0) this.sinks.splice(i, 1);
+    };
+  }
+
+  /**
+   * Deliver a crash report to all sinks. No-throw.
+   *
+   * Scrubbed ONCE, here, before any sink sees it — so no intake and no sink can carry a token or
+   * a phone number off the device (see scrubCrash.ts). If scrubbing itself fails, the report is
+   * reduced to what cannot leak rather than sent raw.
+   */
+  report(report) {
+    const clean = (0, _crashSafe.noThrow)(() => (0, _scrubCrash.scrubCrashFields)(report)) ?? {
+      ...report,
+      message: 'Unscrubbable error message',
+      stack: undefined,
+      metadata: undefined
+    };
+    for (const sink of this.sinks) {
+      (0, _crashSafe.noThrow)(() => sink.deliver(clean));
+    }
+  }
+}
+
+/**
+ * Desktop / analytics sink — emits a `$crash` event through the SDK event
+ * pipeline (debug stream + legacy events). Decoupled from the facade via an
+ * injected track function (Dependency Inversion).
+ */
+exports.CrashReporter = CrashReporter;
+class DesktopEventSink {
+  name = 'desktop';
+  constructor(trackFn) {
+    this.trackFn = trackFn;
+  }
+  deliver(report) {
+    this.trackFn('$crash', {
+      message: report.message,
+      stack: report.stack,
+      isFatal: report.isFatal,
+      type: report.type,
+      source: report.source,
+      screenName: report.screenName,
+      platform: report.platform,
+      ...(report.metadata ?? {})
+    });
+  }
+}
+
+/**
+ * SaaS backend sink — routes the report to the dedicated ingestion errors
+ * endpoint (the data the dashboard Crashes view reads). No-op when no
+ * clientKey-backed session is active.
+ */
+exports.DesktopEventSink = DesktopEventSink;
+class BackendErrorsSink {
+  name = 'backend';
+  deliver(report) {
+    const transport = _SessionManager.SessionManager.getExistingInstance()?.getBackendTransport();
+    if (!transport) return;
+    // D12: this used to forward four fields and drop the rest — so a native
+    // crash's signal/thread/exception-type were captured on device and
+    // discarded one call before the wire, every RN error row had a NULL
+    // platform (making Issue.primaryPlatform mean "web-only"), and fatality
+    // was indistinguishable from a handled error. The receiver has always
+    // accepted all of these.
+    transport.queueError({
+      type: report.type,
+      message: report.message,
+      stack: report.stack,
+      screenName: report.screenName,
+      platform: report.platform,
+      isFatal: report.isFatal,
+      metadata: report.metadata,
+      /**
+       * Carried through so the transport can address the ORIGINAL session.
+       *
+       * Set only on a recovered native crash, whose session died with its process. Omitted
+       * for every live report, where the current session is the right answer — so this
+       * changes nothing about normal error delivery.
+       */
+      ...(report.sessionId ? {
+        sessionId: report.sessionId
+      } : {}),
+      // Becomes SessionError.clientId, which is @unique — that constraint is what turns a
+      // retried crash into one record instead of a duplicate.
+      ...(report.crashId ? {
+        clientId: report.crashId
+      } : {})
+    });
+    // Best-effort immediate delivery so the crash surfaces quickly.
+    transport.flushErrors().catch(() => {});
+  }
+}
+
+// ─── Module singleton ───────────────────────────────────────────────────────
+// A process-wide reporter so any origin (facade, CrashFeature, native drain)
+// reports through the same fan-out without prop-drilling.
+exports.BackendErrorsSink = BackendErrorsSink;
+let _reporter = null;
+
+/** Returns the shared reporter, lazily creating it on first use. */
+function getCrashReporter() {
+  if (!_reporter) _reporter = new CrashReporter();
+  return _reporter;
+}
+
+/** Reset (tests / SDK re-init). */
+function resetCrashReporter() {
+  _reporter = null;
+}
+//# sourceMappingURL=CrashReporter.js.map

package/lib/commonjs/features/crash/NativeCrashFeature.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NativeCrashFeature = void 0;
+var _nativeCrashBridge = require("./nativeCrashBridge");
+var _internalLogger = require("../../core/logger/internalLogger");
+/**
+ * Installs native crash handlers (Android UncaughtExceptionHandler,
+ * iOS NSSetUncaughtExceptionHandler + signal handlers) and drains any
+ * crash record left from the previous process run.
+ *
+ * Runs alongside CrashFeature (which covers JS exceptions via ErrorUtils).
+ * Does not replace or modify the JS handler.
+ */
+class NativeCrashFeature {
+  name = 'crash.native';
+  active = false;
+  initialize(_context) {
+    if (this.active) return;
+    this.active = true;
+
+    // Fire-and-forget: install native handler and drain previous crash.
+    // Failures are swallowed inside each bridge function (noThrow-wrapped).
+    (0, _nativeCrashBridge.installNativeCrashHandler)().catch(() => {});
+    (0, _nativeCrashBridge.drainNativeCrash)().then(found => {
+      if (found) {
+        __DEV__ && _internalLogger.logger.info('[NativeCrashFeature] Previous native crash queued for upload');
+      }
+    }).catch(() => {});
+  }
+  teardown() {
+    // Native crash handlers are process-global — cannot safely uninstall.
+    this.active = false;
+  }
+  get isActive() {
+    return this.active;
+  }
+}
+exports.NativeCrashFeature = NativeCrashFeature;
+//# sourceMappingURL=NativeCrashFeature.js.map

package/lib/commonjs/features/crash/capture.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.captureException = captureException;
+exports.captureMessage = captureMessage;
+var _crashSafe = require("../../core/lifecycle/crashSafe");
+var _CrashReporter = require("./CrashReporter");
+/**
+ * Manual error/message capture — the `Sentry.captureException` equivalent.
+ *
+ * D3: these used to write envelopes into `memoryQueue`, a queue whose only
+ * drain (`Dispatcher.flush`) was registered in the DI container and never
+ * resolved by anything — every capture was accumulated and discarded. They
+ * were also never exported, so the two entry points were reachable by nobody
+ * and delivered to nowhere.
+ *
+ * Now they ride the SAME pipeline as automatic crash capture (CrashReporter →
+ * BackendErrorsSink → `/ingestion/sessions/:id/errors`) — the one path in this
+ * SDK that is proven to land rows.
+ */
+function captureException(error, extra) {
+  (0, _crashSafe.noThrow)(() => {
+    (0, _CrashReporter.getCrashReporter)().report({
+      type: 'handled',
+      message: error.message,
+      stack: error.stack,
+      isFatal: false,
+      source: 'manual',
+      screenName: extra?.screenName,
+      metadata: extra?.metadata
+    });
+  });
+}
+function captureMessage(message, extra) {
+  (0, _crashSafe.noThrow)(() => {
+    (0, _CrashReporter.getCrashReporter)().report({
+      type: 'handled',
+      message,
+      isFatal: false,
+      source: 'manual',
+      screenName: extra?.screenName,
+      metadata: extra?.metadata
+    });
+  });
+}
+//# sourceMappingURL=capture.js.map

package/lib/commonjs/features/crash/globalHandler.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installGlobalHandler = installGlobalHandler;
+var _crashSafe = require("../../core/lifecycle/crashSafe");
+var _internalLogger = require("../../core/logger/internalLogger");
+/**
+ * Install the JS global (uncaught) error handler via React Native's `ErrorUtils`.
+ *
+ * `ErrorUtils` is accessed through `globalThis` rather than imported because:
+ *  - it is a runtime global; importing it from 'react-native' conflicts with the
+ *    ambient global value under `isolatedModules`, and
+ *  - on the New Architecture / bridgeless runtime it may be installed lazily, so
+ *    we feature-detect before use. (Calling it unguarded threw
+ *    "Cannot read property 'getGlobalHandler' of undefined" on New Arch.)
+ *
+ * No-op (logs once) when `ErrorUtils` is unavailable.
+ */
+function installGlobalHandler(onCrash) {
+  (0, _crashSafe.noThrow)(() => {
+    const errorUtils = globalThis.ErrorUtils;
+    if (!errorUtils || typeof errorUtils.getGlobalHandler !== 'function') {
+      __DEV__ && _internalLogger.logger.debug('[Crash] ErrorUtils unavailable — global JS error handler not installed');
+      return;
+    }
+    const originalHandler = errorUtils.getGlobalHandler();
+    errorUtils.setGlobalHandler((error, isFatal) => {
+      __DEV__ && _internalLogger.logger.debug('Caught global error:', error?.message);
+      onCrash(error, !!isFatal);
+
+      // Call original handler to maintain default behavior (e.g. RedBox)
+      if (originalHandler) {
+        originalHandler(error, isFatal);
+      }
+    });
+    __DEV__ && _internalLogger.logger.debug('Global error handler installed');
+  });
+}
+//# sourceMappingURL=globalHandler.js.map

package/lib/commonjs/features/crash/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installCrashReporting = installCrashReporting;
+var _globalHandler = require("./globalHandler");
+var _crashSafe = require("../../core/lifecycle/crashSafe");
+function installCrashReporting(onCrash) {
+  (0, _crashSafe.noThrow)(() => {
+    (0, _globalHandler.installGlobalHandler)(onCrash);
+  });
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/features/crash/nativeCrashBridge.js

@@ -0,0 +1,361 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.drainNativeCrash = drainNativeCrash;
+exports.getNativeActiveSession = getNativeActiveSession;
+exports.installNativeCrashHandler = installNativeCrashHandler;
+exports.persistFatalJsCrash = persistFatalJsCrash;
+exports.setNativeActiveSession = setNativeActiveSession;
+exports.triggerNativeCrash = triggerNativeCrash;
+var _reactNative = require("react-native");
+var _architecture = require("../../core/architecture");
+var _internalLogger = require("../../core/logger/internalLogger");
+var _CrashReporter = require("./CrashReporter");
+var _scrubCrash = require("./scrubCrash");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/**
+ * Wraps the ScaleBunCrash native module (Android/iOS).
+ * Call installNativeCrashHandler() once at SDK init to register handlers.
+ * Call drainNativeCrash() once at SDK init to replay any crash from the previous run.
+ *
+ * Both calls are no-ops when the native module is unavailable (e.g. JS-only
+ * environments, Expo Go without native build).
+ */
+
+let _crashModule;
+function getCrashModule() {
+  if (_crashModule) return _crashModule.mod;
+
+  // New Architecture: prefer the codegen-backed TurboModule. Lazy + guarded so
+  // platforms without TurboModuleRegistry (web/SSR) don't throw at import.
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const turbo = require('../../specs/NativeScaleBunCrash').default;
+    if (turbo) {
+      __DEV__ && _internalLogger.logger.debug(`[NativeCrash] resolved via ${(0, _architecture.nativeModuleVia)()}`);
+      _crashModule = {
+        mod: turbo
+      };
+      return turbo;
+    }
+  } catch {
+    // fall through to the legacy lookup
+  }
+
+  // Old Architecture, New-Arch interop, or no native build.
+  const legacy = _reactNative.NativeModules?.ScaleBunCrash ?? null;
+  if (legacy) _internalLogger.logger.debug('[NativeCrash] resolved via legacy NativeModules');
+  _crashModule = {
+    mod: legacy
+  };
+  return legacy;
+}
+
+/**
+ * Install the native crash handler (UncaughtExceptionHandler on Android,
+ * NSSetUncaughtExceptionHandler + signal handlers on iOS).
+ * Safe to call multiple times — native side is idempotent.
+ */
+/**
+ * Tell native which session is live, so a crash that happens next can name it.
+ *
+ * Called once per session — never per event. Native writes it to crash-safe storage immediately,
+ * because a fatal handler cannot call back into JS to ask, and by the time it runs the JS thread may
+ * already be gone.
+ *
+ * Fire-and-forget and no-throw: losing this degrades a recovered crash to unattributed, which is the
+ * old behaviour. It must never be able to fail a session start.
+ */
+/**
+ * The session last handed to native — which must be the INGESTION session (the `ses-` id whose row
+ * the backend holds), never an id the backend has not seen.
+ *
+ * Kept here so the JS fatal path can stamp the same owner synchronously: persistFatalJsCrash runs
+ * inside the global error handler and cannot await anything.
+ */
+let _activeSessionId = null;
+
+/** The session a crash happening right now belongs to, or null before any session opened. */
+function getNativeActiveSession() {
+  return _activeSessionId;
+}
+async function setNativeActiveSession(sessionId) {
+  if (sessionId) _activeSessionId = sessionId;
+  try {
+    const mod = getCrashModule();
+    if (!mod?.setActiveSessionId || !sessionId) return;
+    await mod.setActiveSessionId(sessionId);
+    __DEV__ && _internalLogger.logger.debug(`[NativeCrash] Active session → ${sessionId}`);
+  } catch {
+    // No-throw
+  }
+}
+async function installNativeCrashHandler() {
+  try {
+    const mod = getCrashModule();
+    if (!mod?.install) {
+      __DEV__ && _internalLogger.logger.debug('[NativeCrash] Native module not available — skipping install');
+      return;
+    }
+    await mod.install();
+    __DEV__ && _internalLogger.logger.debug('[NativeCrash] Handler installed');
+  } catch {
+    // No-throw
+  }
+}
+
+/**
+ * How many pending crashes one launch will deliver.
+ *
+ * The native spool holds three (a device that crashes, restarts offline, and crashes again), but
+ * `drainPendingCrash` hands back the OLDEST ONE ONLY. Draining once per launch therefore needed three
+ * launches to clear three crashes — and a fourth crash evicts the oldest, so on a device crashing in a
+ * loop the spool loses faster than a one-per-launch drain empties it.
+ *
+ * Bounded, not `while (true)`: this loop is driven by native state and stops the moment delivery
+ * fails, but the bound is what makes it impossible for a native bug — a clear that silently does
+ * nothing — to spin the drain forever at startup.
+ */
+const MAX_DRAIN_PER_LAUNCH = 4;
+
+/**
+ * Drain the crash records left from previous process runs.
+ * Returns true if at least one pending crash was found.
+ *
+ * Stops early the first time delivery fails: if the network is down for one crash it is down for the
+ * next, and every extra attempt is a request that cannot succeed made during app startup.
+ */
+async function drainNativeCrash() {
+  let found = false;
+  const seen = new Set();
+  for (let i = 0; i < MAX_DRAIN_PER_LAUNCH; i++) {
+    const outcome = await drainOne(seen);
+    if (outcome === 'none') break;
+    found = true;
+    // 'kept' means the backend did not take it. The rest of the spool is behind the same
+    // network, so stop rather than fail three more times.
+    if (outcome === 'kept') break;
+  }
+  return found;
+}
+
+/** One record: read → report → clear if the backend took it. */
+async function drainOne(seen) {
+  try {
+    const mod = getCrashModule();
+    if (!mod?.drainPendingCrash) return 'none';
+    const crash = await mod.drainPendingCrash();
+    if (!crash) return 'none';
+
+    /*
+     * The same record twice means the previous clear did not take effect — a native failure we
+     * cannot fix from here. Reporting it again would deliver a duplicate on every iteration, so
+     * treat it as the end of the spool.
+     */
+    const seenKey = typeof crash.crashId === 'string' ? crash.crashId : '';
+    // `''` is a deliberate sentinel for the single legacy record, which has no id. Tracking it
+    // too means a legacy clear that silently fails stops the loop instead of redelivering the
+    // same crash on every one of the remaining iterations.
+    if (seen.has(seenKey)) return 'none';
+    seen.add(seenKey);
+    const stackArr = Array.isArray(crash.stackTrace) ? crash.stackTrace : [];
+
+    // 1) Desktop debug stream — keep the rich native-crash envelope.
+    // D2: a rich envelope used to be written here into memoryQueue — a queue
+    // whose drain was never wired, so the native crash's forensic detail was
+    // captured and then discarded. The flattened report below now carries the
+    // same fields in `metadata` (D12), through the pipeline that actually lands.
+
+    // 2) SaaS backend errors endpoint (dashboard Crashes view) — route the
+    // same normalized report through the central reporter. This is what
+    // makes native crashes visible in the dashboard, not just the desktop.
+    const recordType = typeof crash.type === 'string' ? crash.type : 'native';
+    const recordSource = typeof crash.source === 'string' ? crash.source : 'native';
+    (0, _CrashReporter.getCrashReporter)().report({
+      source: recordSource,
+      type: recordType,
+      isFatal: true,
+      message: crash.message ?? crash.exceptionType ?? 'Native crash',
+      stack: stackArr.length ? stackArr.join('\n') : crash.stack ? String(crash.stack) : undefined,
+      // Set for a recovered JS crash; a native crash has no JS screen.
+      ...(crash.screenName ? {
+        screenName: String(crash.screenName)
+      } : {}),
+      platform: crash.platform,
+      /**
+       * THE ORIGINAL SESSION — the entire point of the recovery path.
+       *
+       * This crash happened in a process that no longer exists, so it does NOT belong to the
+       * session running now. Passing it explicitly is what stops the reporter routing it
+       * through the current SessionManager and attributing it to the session created after
+       * the restart.
+       *
+       * Undefined on records written before this shipped, and on a crash that beat the first
+       * session. The sink then keeps the legacy behaviour rather than guessing an owner.
+       */
+      ...(crash.sessionId ? {
+        sessionId: String(crash.sessionId)
+      } : {}),
+      /**
+       * The stable id, carried through so it becomes the backend's dedupe key.
+       *
+       * Written once when the crash was first persisted — never regenerated here. If this were
+       * minted per attempt, every retry would arrive as a brand-new crash and at-least-once
+       * delivery would turn into duplicate-every-time.
+       */
+      ...(crash.crashId ? {
+        crashId: String(crash.crashId)
+      } : {}),
+      metadata: {
+        exceptionType: crash.exceptionType,
+        threadName: crash.threadName,
+        ...(crash.signal !== undefined ? {
+          signal: crash.signal
+        } : {})
+      }
+    });
+
+    /**
+     * DELETE ONLY AFTER THE BACKEND HAS IT.
+     *
+     * The read above is non-destructive, so the crash is still on disk right now. It is removed
+     * only once delivery has actually succeeded — previously the record was destroyed at read
+     * time, so a failed upload lost the crash permanently: the app had proof of a crash, deleted
+     * it, and then failed to send it.
+     *
+     * On failure we simply do NOT clear. The crash stays pending and is retried on the next
+     * launch, which is what makes this at-least-once. Duplicate delivery is safe because the
+     * crash carries a stable `crashId` that the backend dedupes on — a retry produces no second
+     * record.
+     *
+     * A record with no `crashId` is legacy: it predates stable ids, so it cannot be safely
+     * retried (a redelivery WOULD duplicate) and is cleared immediately, preserving exactly the
+     * old at-most-once behaviour for old data rather than silently changing it.
+     */
+    const crashId = seenKey;
+    if (!crashId) {
+      await mod.clearPendingCrash?.('');
+      __DEV__ && _internalLogger.logger.info('[NativeCrash] Legacy crash (no id) drained and cleared');
+      return 'cleared';
+    }
+    const delivered = await confirmDelivery();
+    if (delivered) {
+      await mod.clearPendingCrash?.(crashId);
+      __DEV__ && _internalLogger.logger.info(`[NativeCrash] Crash ${crashId} delivered → cleared`);
+      return 'cleared';
+    }
+    __DEV__ && _internalLogger.logger.info(`[NativeCrash] Crash ${crashId} not yet delivered → kept for retry`);
+    return 'kept';
+  } catch {
+    // Unknown state — stop the loop rather than risk spinning on a failure we cannot diagnose.
+    return 'none';
+  }
+}
+
+/**
+ * Has the crash actually reached the backend?
+ *
+ * The reporter's sinks are fire-and-forget by design (a crash report must never block or throw), so
+ * "delivered" is asked of the transport rather than inferred from `report()` returning. If the
+ * transport is not up yet — the drain can win the race against SessionManager — the answer is NO and
+ * the crash stays on disk for the next launch. That is strictly better than the old behaviour, where
+ * exactly that race deleted the record and dropped the crash silently.
+ */
+async function confirmDelivery() {
+  try {
+    const {
+      SessionManager
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('../session/SessionManager')));
+    const transport = SessionManager.getExistingInstance()?.getBackendTransport();
+    // No transport yet — the drain can win the startup race. That is a delivery FAILURE, not a
+    // reason to give up: the record stays on disk and the next launch retries it. This exact
+    // path used to delete the crash and send nothing.
+    if (!transport) return false;
+    /**
+     * The BOOLEAN, not merely "it resolved".
+     *
+     * flushErrors used to return void and swallow its own errors, so awaiting it proved only
+     * that the call finished. Deleting a crash on that basis would have thrown away crashes
+     * that never reached the backend — the failure this whole change exists to prevent.
+     */
+    return (await transport.flushErrors()) === true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * DEV/TEST ONLY — ask the native module to crash the process right now, so the
+ * native handler captures it and the next launch drains it to the backend.
+ * No-op when the native module or `crashNow` is unavailable.
+ */
+async function triggerNativeCrash() {
+  try {
+    const mod = getCrashModule();
+    if (!mod?.crashNow) {
+      _internalLogger.logger.warn('[NativeCrash] crashNow unavailable — rebuild native app to enable');
+      return;
+    }
+    await mod.crashNow();
+  } catch {
+    // The process is expected to die; nothing to handle.
+  }
+}
+/**
+ * Persist a FATAL JS crash to disk BEFORE the process dies.
+ *
+ * A fatal JS error tears the process down almost immediately. The normal error
+ * path queues the crash and POSTs it asynchronously, which loses the race: the
+ * process is gone before the request finishes, and nothing is on disk to retry.
+ * This is why a JS crash could vanish while a native one always survived.
+ *
+ * The fix is the native module's SYNCHRONOUS persistJsCrash: it writes the
+ * record to the same store native crashes use and returns before this function
+ * returns — so by the time the JS handler unwinds, the crash is durable. The
+ * existing drain path then delivers it on the next launch, at least once,
+ * deduped on crashId.
+ *
+ * Synchronous and no-throw by construction: this runs inside the global error
+ * handler, where an exception would replace one crash with another.
+ */
+function persistFatalJsCrash(input) {
+  try {
+    const mod = getCrashModule();
+    if (!mod?.persistJsCrash) return false;
+    // Minted once, here, so a retry from disk dedupes on the backend rather
+    // than arriving as a fresh crash every launch.
+    const crashId = `jscrash-${nowMs()}-${counter()}`;
+    const record = {
+      crashId,
+      type: 'crash',
+      source: 'js',
+      isFatal: true,
+      // Scrubbed before it touches disk: this record is written BEFORE the reporter runs,
+      // and it sits in the app's storage until the next launch delivers it.
+      message: (0, _scrubCrash.scrubText)(input.message),
+      stack: (0, _scrubCrash.scrubStack)(input.stack),
+      screenName: input.screenName,
+      platform: input.platform,
+      // The owner of THIS crash: the next launch is a different session, and a record with
+      // no id would be filed under that one when it is drained.
+      sessionId: input.sessionId ?? _activeSessionId ?? undefined,
+      timestamp: new Date().toISOString()
+    };
+    return mod.persistJsCrash(JSON.stringify(record)) === true;
+  } catch {
+    return false;
+  }
+}
+
+/** Monotonic-ish parts for a unique id without pulling in a uuid dependency. */
+let _seq = 0;
+function counter() {
+  _seq = (_seq + 1) % 1_000_000;
+  return _seq;
+}
+function nowMs() {
+  return Date.now();
+}
+//# sourceMappingURL=nativeCrashBridge.js.map