@koderlabs/tasks-sdk-rn-native 0.1.0

package/dist/index.cjs

@@ -0,0 +1,132 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  enableNativeCapture: () => enableNativeCapture,
+  generateTestNativeReport: () => generateTestNativeReport,
+  getPendingNativeCrash: () => getPendingNativeCrash,
+  purgePendingNativeCrash: () => purgePendingNativeCrash
+});
+module.exports = __toCommonJS(index_exports);
+function loadNative(onError) {
+  try {
+    const core = (typeof require !== "undefined" ? require : null)?.("expo-modules-core");
+    if (!core?.requireOptionalNativeModule) {
+      onError?.({
+        stage: "require-core",
+        message: "expo-modules-core not available"
+      });
+      return null;
+    }
+    const mod = core.requireOptionalNativeModule("TasksSdkRnNative");
+    if (!mod) onError?.({
+      stage: "require-native",
+      message: "TasksSdkRnNative native module not present"
+    });
+    return mod;
+  } catch (e) {
+    onError?.({
+      stage: "require-core",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(loadNative, "loadNative");
+var native;
+function getNative(onError) {
+  if (native === void 0) native = loadNative(onError);
+  return native ?? null;
+}
+__name(getNative, "getNative");
+async function enableNativeCapture(opts = {}) {
+  const mod = getNative(opts.onError);
+  if (!mod) return false;
+  try {
+    const ok = await mod.enableCrashReporter();
+    if (opts.enableAnrWatchdog && mod.enableAnrWatchdog) {
+      await mod.enableAnrWatchdog(opts.anrThresholdMs ?? 5e3);
+    }
+    return ok;
+  } catch (e) {
+    opts.onError?.({
+      stage: "enable",
+      message: e.message,
+      cause: e
+    });
+    return false;
+  }
+}
+__name(enableNativeCapture, "enableNativeCapture");
+async function getPendingNativeCrash(onError) {
+  const mod = getNative(onError);
+  if (!mod) return null;
+  try {
+    return await mod.getPendingCrashReport();
+  } catch (e) {
+    onError?.({
+      stage: "get-report",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(getPendingNativeCrash, "getPendingNativeCrash");
+async function purgePendingNativeCrash(onError) {
+  const mod = getNative(onError);
+  if (!mod) return;
+  try {
+    await mod.purgePendingCrashReport();
+  } catch (e) {
+    onError?.({
+      stage: "purge",
+      message: e.message,
+      cause: e
+    });
+  }
+}
+__name(purgePendingNativeCrash, "purgePendingNativeCrash");
+async function generateTestNativeReport(onError) {
+  const mod = getNative(onError);
+  if (!mod?.generateTestReport) return null;
+  try {
+    return await mod.generateTestReport();
+  } catch (e) {
+    onError?.({
+      stage: "test-report",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(generateTestNativeReport, "generateTestNativeReport");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enableNativeCapture,
+  generateTestNativeReport,
+  getPendingNativeCrash,
+  purgePendingNativeCrash
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @koderlabs/tasks-sdk-rn-native — native crash + ANR capture for RN.\n *\n * Companion package to `@koderlabs/tasks-sdk-rn`. When installed and\n * registered via `app.json#plugins`, this package:\n *\n *   iOS:\n *     - Bundles PLCrashReporter as a Pod\n *     - Catches Mach exceptions, BSD signals (SIGSEGV/SIGBUS/SIGABRT/...)\n *       and ObjC NSExceptions\n *     - Reports are decoded on next launch and shipped via the JS SDK\n *\n *   Android:\n *     - JNI signal handler (libtasks_native_crash.so) for SIGSEGV/SIGBUS/\n *       SIGABRT/SIGFPE/SIGILL with backtrace addresses\n *     - Optional ANR watchdog thread (off by default — needs explicit\n *       opt-in because false-positives on slow devices are common)\n *     - Reports written to filesDir, shipped on next launch\n *\n * The JS API is intentionally minimal — register early at app boot, then\n * the package operates passively until a crash happens.\n *\n * Limitations (acknowledged in README):\n *   - Symbol resolution requires CLI source-map upload for .so files\n *     (planned follow-up).\n *   - Crashpad/Breakpad integration is NOT included — would replace the\n *     custom signal handler for richer stack walks. Separate package.\n *   - Re-entrant crashes inside the handler are not detected.\n */\n// We require this dynamically so Node tests don't try to load it.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExpoModulesCore = { requireOptionalNativeModule: (name: string) => any };\n\ninterface NativeCrashReport {\n  platform: 'ios' | 'android';\n  kind?: 'native_signal' | 'anr' | 'nsexception';\n  timestamp?: string;\n  signal?: string;\n  faultAddr?: string;\n  exception?: { name?: string; reason?: string };\n  threads?: Array<{ threadNumber: number; crashed: boolean; frames: Array<{ instructionPointer: number; symbol?: string | null }> }>;\n  images?: Array<{ name: string; baseAddress: number; size: number; uuid: string }>;\n  frames?: string[];\n  stack?: string[];\n  thresholdMs?: number;\n  capturedAt?: string;\n}\n\ninterface TasksNativeModule {\n  enableCrashReporter(): Promise<boolean>;\n  enableAnrWatchdog?(thresholdMs: number): Promise<boolean>;\n  getPendingCrashReport(): Promise<NativeCrashReport | null>;\n  purgePendingCrashReport(): Promise<boolean>;\n  generateTestReport?(): Promise<{ captured: boolean; timestamp: string }>;\n}\n\n/**\n * Native module handle. Returns `null` when:\n *   - The package is installed but the native side hasn't been prebuilt\n *     (managed Expo Go can't load native code — only EAS Build)\n *   - The host platform is web / Node tests\n * In those cases the JS layer falls back to the SDK-RN-only behaviour.\n */\nfunction loadNative(onError?: NativeErrorHandler): TasksNativeModule | null {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const core = (typeof require !== 'undefined' ? require : null)?.('expo-modules-core') as ExpoModulesCore | null;\n    if (!core?.requireOptionalNativeModule) {\n      onError?.({ stage: 'require-core', message: 'expo-modules-core not available' });\n      return null;\n    }\n    const mod = core.requireOptionalNativeModule('TasksSdkRnNative') as TasksNativeModule | null;\n    if (!mod) onError?.({ stage: 'require-native', message: 'TasksSdkRnNative native module not present' });\n    return mod;\n  } catch (e) {\n    onError?.({ stage: 'require-core', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\n/**\n * Tagged error reason so callers can distinguish \"native not installed\" from\n * a runtime failure that genuinely silenced crash reporting.\n */\nexport interface NativeError {\n  stage: 'require-core' | 'require-native' | 'enable' | 'get-report' | 'purge' | 'test-report';\n  message: string;\n  cause?: unknown;\n}\nexport type NativeErrorHandler = (err: NativeError) => void;\n\n// Lazy singleton — loaded on first enableNativeCapture() to keep module-import\n// cheap and to avoid web/Node bundlers walking expo-modules-core at build time.\nlet native: TasksNativeModule | null | undefined; // undefined = unloaded\n\nexport interface EnableOptions {\n  /**\n   * Enable Android ANR watchdog. Default `false` because soft watchdogs\n   * are noisy on slow devices and the OS does its own ANR detection. Only\n   * worth enabling during dev or for apps with strict perf budgets.\n   */\n  enableAnrWatchdog?: boolean;\n  /** ANR threshold in ms. Default 5000 (matches OS-level Activity ANR). */\n  anrThresholdMs?: number;\n  /**\n   * Surface load/runtime errors instead of silently returning false.\n   * Operators rely on this to detect when crash capture stops working —\n   * the \"no crash\" state is otherwise indistinguishable from \"decode failed\".\n   */\n  onError?: NativeErrorHandler;\n}\n\nfunction getNative(onError?: NativeErrorHandler): TasksNativeModule | null {\n  if (native === undefined) native = loadNative(onError);\n  return native ?? null;\n}\n\n/**\n * Install native crash + (optional) ANR handlers. Idempotent — second call\n * is a no-op at the native layer. Safe to call before user authentication\n * is established.\n */\nexport async function enableNativeCapture(opts: EnableOptions = {}): Promise<boolean> {\n  const mod = getNative(opts.onError);\n  if (!mod) return false;\n  try {\n    const ok = await mod.enableCrashReporter();\n    if (opts.enableAnrWatchdog && mod.enableAnrWatchdog) {\n      await mod.enableAnrWatchdog(opts.anrThresholdMs ?? 5000);\n    }\n    return ok;\n  } catch (e) {\n    opts.onError?.({ stage: 'enable', message: (e as Error).message, cause: e });\n    return false;\n  }\n}\n\n/**\n * Pull the previous-launch crash report. Returns `null` if no pending crash\n * was found, the native module isn't loaded, or the read failed. After the\n * caller has shipped the event upstream, call `purgePendingNativeCrash()`\n * to delete the on-disk report.\n */\nexport async function getPendingNativeCrash(onError?: NativeErrorHandler): Promise<NativeCrashReport | null> {\n  const mod = getNative(onError);\n  if (!mod) return null;\n  try {\n    return await mod.getPendingCrashReport();\n  } catch (e) {\n    onError?.({ stage: 'get-report', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\n/**\n * Delete the on-disk crash report so it isn't shipped a second time.\n * Always safe to call — no-op when nothing's there.\n */\nexport async function purgePendingNativeCrash(onError?: NativeErrorHandler): Promise<void> {\n  const mod = getNative(onError);\n  if (!mod) return;\n  try {\n    await mod.purgePendingCrashReport();\n  } catch (e) {\n    onError?.({ stage: 'purge', message: (e as Error).message, cause: e });\n  }\n}\n\n/**\n * Generate a test crash report without crashing the process. Used for\n * verifying integration end-to-end during dev / CI.\n */\nexport async function generateTestNativeReport(onError?: NativeErrorHandler): Promise<{ captured: boolean; timestamp: string } | null> {\n  const mod = getNative(onError);\n  if (!mod?.generateTestReport) return null;\n  try {\n    return await mod.generateTestReport();\n  } catch (e) {\n    onError?.({ stage: 'test-report', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\nexport type { NativeCrashReport };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;AA+DA,SAASA,WAAWC,SAA4B;AAC9C,MAAI;AAEF,UAAMC,QAAQ,OAAOC,YAAY,cAAcA,UAAU,QAAQ,mBAAA;AACjE,QAAI,CAACD,MAAME,6BAA6B;AACtCH,gBAAU;QAAEI,OAAO;QAAgBC,SAAS;MAAkC,CAAA;AAC9E,aAAO;IACT;AACA,UAAMC,MAAML,KAAKE,4BAA4B,kBAAA;AAC7C,QAAI,CAACG,IAAKN,WAAU;MAAEI,OAAO;MAAkBC,SAAS;IAA6C,CAAA;AACrG,WAAOC;EACT,SAASC,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAgBC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC3E,WAAO;EACT;AACF;AAfSR;AA8BT,IAAIU;AAmBJ,SAASC,UAAUV,SAA4B;AAC7C,MAAIS,WAAWE,OAAWF,UAASV,WAAWC,OAAAA;AAC9C,SAAOS,UAAU;AACnB;AAHSC;AAUT,eAAsBE,oBAAoBC,OAAsB,CAAC,GAAC;AAChE,QAAMP,MAAMI,UAAUG,KAAKb,OAAO;AAClC,MAAI,CAACM,IAAK,QAAO;AACjB,MAAI;AACF,UAAMQ,KAAK,MAAMR,IAAIS,oBAAmB;AACxC,QAAIF,KAAKG,qBAAqBV,IAAIU,mBAAmB;AACnD,YAAMV,IAAIU,kBAAkBH,KAAKI,kBAAkB,GAAA;IACrD;AACA,WAAOH;EACT,SAASP,GAAG;AACVM,SAAKb,UAAU;MAAEI,OAAO;MAAUC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC1E,WAAO;EACT;AACF;AAbsBK;AAqBtB,eAAsBM,sBAAsBlB,SAA4B;AACtE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,IAAK,QAAO;AACjB,MAAI;AACF,WAAO,MAAMA,IAAIa,sBAAqB;EACxC,SAASZ,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAcC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AACzE,WAAO;EACT;AACF;AATsBW;AAetB,eAAsBE,wBAAwBpB,SAA4B;AACxE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,IAAK;AACV,MAAI;AACF,UAAMA,IAAIe,wBAAuB;EACnC,SAASd,GAAG;AACVP,cAAU;MAAEI,OAAO;MAASC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;EACtE;AACF;AARsBa;AActB,eAAsBE,yBAAyBtB,SAA4B;AACzE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,KAAKiB,mBAAoB,QAAO;AACrC,MAAI;AACF,WAAO,MAAMjB,IAAIiB,mBAAkB;EACrC,SAAShB,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAeC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC1E,WAAO;EACT;AACF;AATsBe;","names":["loadNative","onError","core","require","requireOptionalNativeModule","stage","message","mod","e","cause","native","getNative","undefined","enableNativeCapture","opts","ok","enableCrashReporter","enableAnrWatchdog","anrThresholdMs","getPendingNativeCrash","getPendingCrashReport","purgePendingNativeCrash","purgePendingCrashReport","generateTestNativeReport","generateTestReport"]}

package/dist/index.d.cts

@@ -0,0 +1,83 @@
+interface NativeCrashReport {
+    platform: 'ios' | 'android';
+    kind?: 'native_signal' | 'anr' | 'nsexception';
+    timestamp?: string;
+    signal?: string;
+    faultAddr?: string;
+    exception?: {
+        name?: string;
+        reason?: string;
+    };
+    threads?: Array<{
+        threadNumber: number;
+        crashed: boolean;
+        frames: Array<{
+            instructionPointer: number;
+            symbol?: string | null;
+        }>;
+    }>;
+    images?: Array<{
+        name: string;
+        baseAddress: number;
+        size: number;
+        uuid: string;
+    }>;
+    frames?: string[];
+    stack?: string[];
+    thresholdMs?: number;
+    capturedAt?: string;
+}
+/**
+ * Tagged error reason so callers can distinguish "native not installed" from
+ * a runtime failure that genuinely silenced crash reporting.
+ */
+interface NativeError {
+    stage: 'require-core' | 'require-native' | 'enable' | 'get-report' | 'purge' | 'test-report';
+    message: string;
+    cause?: unknown;
+}
+type NativeErrorHandler = (err: NativeError) => void;
+interface EnableOptions {
+    /**
+     * Enable Android ANR watchdog. Default `false` because soft watchdogs
+     * are noisy on slow devices and the OS does its own ANR detection. Only
+     * worth enabling during dev or for apps with strict perf budgets.
+     */
+    enableAnrWatchdog?: boolean;
+    /** ANR threshold in ms. Default 5000 (matches OS-level Activity ANR). */
+    anrThresholdMs?: number;
+    /**
+     * Surface load/runtime errors instead of silently returning false.
+     * Operators rely on this to detect when crash capture stops working —
+     * the "no crash" state is otherwise indistinguishable from "decode failed".
+     */
+    onError?: NativeErrorHandler;
+}
+/**
+ * Install native crash + (optional) ANR handlers. Idempotent — second call
+ * is a no-op at the native layer. Safe to call before user authentication
+ * is established.
+ */
+declare function enableNativeCapture(opts?: EnableOptions): Promise<boolean>;
+/**
+ * Pull the previous-launch crash report. Returns `null` if no pending crash
+ * was found, the native module isn't loaded, or the read failed. After the
+ * caller has shipped the event upstream, call `purgePendingNativeCrash()`
+ * to delete the on-disk report.
+ */
+declare function getPendingNativeCrash(onError?: NativeErrorHandler): Promise<NativeCrashReport | null>;
+/**
+ * Delete the on-disk crash report so it isn't shipped a second time.
+ * Always safe to call — no-op when nothing's there.
+ */
+declare function purgePendingNativeCrash(onError?: NativeErrorHandler): Promise<void>;
+/**
+ * Generate a test crash report without crashing the process. Used for
+ * verifying integration end-to-end during dev / CI.
+ */
+declare function generateTestNativeReport(onError?: NativeErrorHandler): Promise<{
+    captured: boolean;
+    timestamp: string;
+} | null>;
+
+export { type EnableOptions, type NativeCrashReport, type NativeError, type NativeErrorHandler, enableNativeCapture, generateTestNativeReport, getPendingNativeCrash, purgePendingNativeCrash };

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+interface NativeCrashReport {
+    platform: 'ios' | 'android';
+    kind?: 'native_signal' | 'anr' | 'nsexception';
+    timestamp?: string;
+    signal?: string;
+    faultAddr?: string;
+    exception?: {
+        name?: string;
+        reason?: string;
+    };
+    threads?: Array<{
+        threadNumber: number;
+        crashed: boolean;
+        frames: Array<{
+            instructionPointer: number;
+            symbol?: string | null;
+        }>;
+    }>;
+    images?: Array<{
+        name: string;
+        baseAddress: number;
+        size: number;
+        uuid: string;
+    }>;
+    frames?: string[];
+    stack?: string[];
+    thresholdMs?: number;
+    capturedAt?: string;
+}
+/**
+ * Tagged error reason so callers can distinguish "native not installed" from
+ * a runtime failure that genuinely silenced crash reporting.
+ */
+interface NativeError {
+    stage: 'require-core' | 'require-native' | 'enable' | 'get-report' | 'purge' | 'test-report';
+    message: string;
+    cause?: unknown;
+}
+type NativeErrorHandler = (err: NativeError) => void;
+interface EnableOptions {
+    /**
+     * Enable Android ANR watchdog. Default `false` because soft watchdogs
+     * are noisy on slow devices and the OS does its own ANR detection. Only
+     * worth enabling during dev or for apps with strict perf budgets.
+     */
+    enableAnrWatchdog?: boolean;
+    /** ANR threshold in ms. Default 5000 (matches OS-level Activity ANR). */
+    anrThresholdMs?: number;
+    /**
+     * Surface load/runtime errors instead of silently returning false.
+     * Operators rely on this to detect when crash capture stops working —
+     * the "no crash" state is otherwise indistinguishable from "decode failed".
+     */
+    onError?: NativeErrorHandler;
+}
+/**
+ * Install native crash + (optional) ANR handlers. Idempotent — second call
+ * is a no-op at the native layer. Safe to call before user authentication
+ * is established.
+ */
+declare function enableNativeCapture(opts?: EnableOptions): Promise<boolean>;
+/**
+ * Pull the previous-launch crash report. Returns `null` if no pending crash
+ * was found, the native module isn't loaded, or the read failed. After the
+ * caller has shipped the event upstream, call `purgePendingNativeCrash()`
+ * to delete the on-disk report.
+ */
+declare function getPendingNativeCrash(onError?: NativeErrorHandler): Promise<NativeCrashReport | null>;
+/**
+ * Delete the on-disk crash report so it isn't shipped a second time.
+ * Always safe to call — no-op when nothing's there.
+ */
+declare function purgePendingNativeCrash(onError?: NativeErrorHandler): Promise<void>;
+/**
+ * Generate a test crash report without crashing the process. Used for
+ * verifying integration end-to-end during dev / CI.
+ */
+declare function generateTestNativeReport(onError?: NativeErrorHandler): Promise<{
+    captured: boolean;
+    timestamp: string;
+} | null>;
+
+export { type EnableOptions, type NativeCrashReport, type NativeError, type NativeErrorHandler, enableNativeCapture, generateTestNativeReport, getPendingNativeCrash, purgePendingNativeCrash };

package/dist/index.js

@@ -0,0 +1,112 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+function loadNative(onError) {
+  try {
+    const core = (typeof __require !== "undefined" ? __require : null)?.("expo-modules-core");
+    if (!core?.requireOptionalNativeModule) {
+      onError?.({
+        stage: "require-core",
+        message: "expo-modules-core not available"
+      });
+      return null;
+    }
+    const mod = core.requireOptionalNativeModule("TasksSdkRnNative");
+    if (!mod) onError?.({
+      stage: "require-native",
+      message: "TasksSdkRnNative native module not present"
+    });
+    return mod;
+  } catch (e) {
+    onError?.({
+      stage: "require-core",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(loadNative, "loadNative");
+var native;
+function getNative(onError) {
+  if (native === void 0) native = loadNative(onError);
+  return native ?? null;
+}
+__name(getNative, "getNative");
+async function enableNativeCapture(opts = {}) {
+  const mod = getNative(opts.onError);
+  if (!mod) return false;
+  try {
+    const ok = await mod.enableCrashReporter();
+    if (opts.enableAnrWatchdog && mod.enableAnrWatchdog) {
+      await mod.enableAnrWatchdog(opts.anrThresholdMs ?? 5e3);
+    }
+    return ok;
+  } catch (e) {
+    opts.onError?.({
+      stage: "enable",
+      message: e.message,
+      cause: e
+    });
+    return false;
+  }
+}
+__name(enableNativeCapture, "enableNativeCapture");
+async function getPendingNativeCrash(onError) {
+  const mod = getNative(onError);
+  if (!mod) return null;
+  try {
+    return await mod.getPendingCrashReport();
+  } catch (e) {
+    onError?.({
+      stage: "get-report",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(getPendingNativeCrash, "getPendingNativeCrash");
+async function purgePendingNativeCrash(onError) {
+  const mod = getNative(onError);
+  if (!mod) return;
+  try {
+    await mod.purgePendingCrashReport();
+  } catch (e) {
+    onError?.({
+      stage: "purge",
+      message: e.message,
+      cause: e
+    });
+  }
+}
+__name(purgePendingNativeCrash, "purgePendingNativeCrash");
+async function generateTestNativeReport(onError) {
+  const mod = getNative(onError);
+  if (!mod?.generateTestReport) return null;
+  try {
+    return await mod.generateTestReport();
+  } catch (e) {
+    onError?.({
+      stage: "test-report",
+      message: e.message,
+      cause: e
+    });
+    return null;
+  }
+}
+__name(generateTestNativeReport, "generateTestNativeReport");
+export {
+  enableNativeCapture,
+  generateTestNativeReport,
+  getPendingNativeCrash,
+  purgePendingNativeCrash
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * @koderlabs/tasks-sdk-rn-native — native crash + ANR capture for RN.\n *\n * Companion package to `@koderlabs/tasks-sdk-rn`. When installed and\n * registered via `app.json#plugins`, this package:\n *\n *   iOS:\n *     - Bundles PLCrashReporter as a Pod\n *     - Catches Mach exceptions, BSD signals (SIGSEGV/SIGBUS/SIGABRT/...)\n *       and ObjC NSExceptions\n *     - Reports are decoded on next launch and shipped via the JS SDK\n *\n *   Android:\n *     - JNI signal handler (libtasks_native_crash.so) for SIGSEGV/SIGBUS/\n *       SIGABRT/SIGFPE/SIGILL with backtrace addresses\n *     - Optional ANR watchdog thread (off by default — needs explicit\n *       opt-in because false-positives on slow devices are common)\n *     - Reports written to filesDir, shipped on next launch\n *\n * The JS API is intentionally minimal — register early at app boot, then\n * the package operates passively until a crash happens.\n *\n * Limitations (acknowledged in README):\n *   - Symbol resolution requires CLI source-map upload for .so files\n *     (planned follow-up).\n *   - Crashpad/Breakpad integration is NOT included — would replace the\n *     custom signal handler for richer stack walks. Separate package.\n *   - Re-entrant crashes inside the handler are not detected.\n */\n// We require this dynamically so Node tests don't try to load it.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype ExpoModulesCore = { requireOptionalNativeModule: (name: string) => any };\n\ninterface NativeCrashReport {\n  platform: 'ios' | 'android';\n  kind?: 'native_signal' | 'anr' | 'nsexception';\n  timestamp?: string;\n  signal?: string;\n  faultAddr?: string;\n  exception?: { name?: string; reason?: string };\n  threads?: Array<{ threadNumber: number; crashed: boolean; frames: Array<{ instructionPointer: number; symbol?: string | null }> }>;\n  images?: Array<{ name: string; baseAddress: number; size: number; uuid: string }>;\n  frames?: string[];\n  stack?: string[];\n  thresholdMs?: number;\n  capturedAt?: string;\n}\n\ninterface TasksNativeModule {\n  enableCrashReporter(): Promise<boolean>;\n  enableAnrWatchdog?(thresholdMs: number): Promise<boolean>;\n  getPendingCrashReport(): Promise<NativeCrashReport | null>;\n  purgePendingCrashReport(): Promise<boolean>;\n  generateTestReport?(): Promise<{ captured: boolean; timestamp: string }>;\n}\n\n/**\n * Native module handle. Returns `null` when:\n *   - The package is installed but the native side hasn't been prebuilt\n *     (managed Expo Go can't load native code — only EAS Build)\n *   - The host platform is web / Node tests\n * In those cases the JS layer falls back to the SDK-RN-only behaviour.\n */\nfunction loadNative(onError?: NativeErrorHandler): TasksNativeModule | null {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const core = (typeof require !== 'undefined' ? require : null)?.('expo-modules-core') as ExpoModulesCore | null;\n    if (!core?.requireOptionalNativeModule) {\n      onError?.({ stage: 'require-core', message: 'expo-modules-core not available' });\n      return null;\n    }\n    const mod = core.requireOptionalNativeModule('TasksSdkRnNative') as TasksNativeModule | null;\n    if (!mod) onError?.({ stage: 'require-native', message: 'TasksSdkRnNative native module not present' });\n    return mod;\n  } catch (e) {\n    onError?.({ stage: 'require-core', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\n/**\n * Tagged error reason so callers can distinguish \"native not installed\" from\n * a runtime failure that genuinely silenced crash reporting.\n */\nexport interface NativeError {\n  stage: 'require-core' | 'require-native' | 'enable' | 'get-report' | 'purge' | 'test-report';\n  message: string;\n  cause?: unknown;\n}\nexport type NativeErrorHandler = (err: NativeError) => void;\n\n// Lazy singleton — loaded on first enableNativeCapture() to keep module-import\n// cheap and to avoid web/Node bundlers walking expo-modules-core at build time.\nlet native: TasksNativeModule | null | undefined; // undefined = unloaded\n\nexport interface EnableOptions {\n  /**\n   * Enable Android ANR watchdog. Default `false` because soft watchdogs\n   * are noisy on slow devices and the OS does its own ANR detection. Only\n   * worth enabling during dev or for apps with strict perf budgets.\n   */\n  enableAnrWatchdog?: boolean;\n  /** ANR threshold in ms. Default 5000 (matches OS-level Activity ANR). */\n  anrThresholdMs?: number;\n  /**\n   * Surface load/runtime errors instead of silently returning false.\n   * Operators rely on this to detect when crash capture stops working —\n   * the \"no crash\" state is otherwise indistinguishable from \"decode failed\".\n   */\n  onError?: NativeErrorHandler;\n}\n\nfunction getNative(onError?: NativeErrorHandler): TasksNativeModule | null {\n  if (native === undefined) native = loadNative(onError);\n  return native ?? null;\n}\n\n/**\n * Install native crash + (optional) ANR handlers. Idempotent — second call\n * is a no-op at the native layer. Safe to call before user authentication\n * is established.\n */\nexport async function enableNativeCapture(opts: EnableOptions = {}): Promise<boolean> {\n  const mod = getNative(opts.onError);\n  if (!mod) return false;\n  try {\n    const ok = await mod.enableCrashReporter();\n    if (opts.enableAnrWatchdog && mod.enableAnrWatchdog) {\n      await mod.enableAnrWatchdog(opts.anrThresholdMs ?? 5000);\n    }\n    return ok;\n  } catch (e) {\n    opts.onError?.({ stage: 'enable', message: (e as Error).message, cause: e });\n    return false;\n  }\n}\n\n/**\n * Pull the previous-launch crash report. Returns `null` if no pending crash\n * was found, the native module isn't loaded, or the read failed. After the\n * caller has shipped the event upstream, call `purgePendingNativeCrash()`\n * to delete the on-disk report.\n */\nexport async function getPendingNativeCrash(onError?: NativeErrorHandler): Promise<NativeCrashReport | null> {\n  const mod = getNative(onError);\n  if (!mod) return null;\n  try {\n    return await mod.getPendingCrashReport();\n  } catch (e) {\n    onError?.({ stage: 'get-report', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\n/**\n * Delete the on-disk crash report so it isn't shipped a second time.\n * Always safe to call — no-op when nothing's there.\n */\nexport async function purgePendingNativeCrash(onError?: NativeErrorHandler): Promise<void> {\n  const mod = getNative(onError);\n  if (!mod) return;\n  try {\n    await mod.purgePendingCrashReport();\n  } catch (e) {\n    onError?.({ stage: 'purge', message: (e as Error).message, cause: e });\n  }\n}\n\n/**\n * Generate a test crash report without crashing the process. Used for\n * verifying integration end-to-end during dev / CI.\n */\nexport async function generateTestNativeReport(onError?: NativeErrorHandler): Promise<{ captured: boolean; timestamp: string } | null> {\n  const mod = getNative(onError);\n  if (!mod?.generateTestReport) return null;\n  try {\n    return await mod.generateTestReport();\n  } catch (e) {\n    onError?.({ stage: 'test-report', message: (e as Error).message, cause: e });\n    return null;\n  }\n}\n\nexport type { NativeCrashReport };\n"],"mappings":";;;;;;;;;;AA+DA,SAASA,WAAWC,SAA4B;AAC9C,MAAI;AAEF,UAAMC,QAAQ,OAAOC,cAAY,cAAcA,YAAU,QAAQ,mBAAA;AACjE,QAAI,CAACD,MAAME,6BAA6B;AACtCH,gBAAU;QAAEI,OAAO;QAAgBC,SAAS;MAAkC,CAAA;AAC9E,aAAO;IACT;AACA,UAAMC,MAAML,KAAKE,4BAA4B,kBAAA;AAC7C,QAAI,CAACG,IAAKN,WAAU;MAAEI,OAAO;MAAkBC,SAAS;IAA6C,CAAA;AACrG,WAAOC;EACT,SAASC,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAgBC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC3E,WAAO;EACT;AACF;AAfSR;AA8BT,IAAIU;AAmBJ,SAASC,UAAUV,SAA4B;AAC7C,MAAIS,WAAWE,OAAWF,UAASV,WAAWC,OAAAA;AAC9C,SAAOS,UAAU;AACnB;AAHSC;AAUT,eAAsBE,oBAAoBC,OAAsB,CAAC,GAAC;AAChE,QAAMP,MAAMI,UAAUG,KAAKb,OAAO;AAClC,MAAI,CAACM,IAAK,QAAO;AACjB,MAAI;AACF,UAAMQ,KAAK,MAAMR,IAAIS,oBAAmB;AACxC,QAAIF,KAAKG,qBAAqBV,IAAIU,mBAAmB;AACnD,YAAMV,IAAIU,kBAAkBH,KAAKI,kBAAkB,GAAA;IACrD;AACA,WAAOH;EACT,SAASP,GAAG;AACVM,SAAKb,UAAU;MAAEI,OAAO;MAAUC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC1E,WAAO;EACT;AACF;AAbsBK;AAqBtB,eAAsBM,sBAAsBlB,SAA4B;AACtE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,IAAK,QAAO;AACjB,MAAI;AACF,WAAO,MAAMA,IAAIa,sBAAqB;EACxC,SAASZ,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAcC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AACzE,WAAO;EACT;AACF;AATsBW;AAetB,eAAsBE,wBAAwBpB,SAA4B;AACxE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,IAAK;AACV,MAAI;AACF,UAAMA,IAAIe,wBAAuB;EACnC,SAASd,GAAG;AACVP,cAAU;MAAEI,OAAO;MAASC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;EACtE;AACF;AARsBa;AActB,eAAsBE,yBAAyBtB,SAA4B;AACzE,QAAMM,MAAMI,UAAUV,OAAAA;AACtB,MAAI,CAACM,KAAKiB,mBAAoB,QAAO;AACrC,MAAI;AACF,WAAO,MAAMjB,IAAIiB,mBAAkB;EACrC,SAAShB,GAAG;AACVP,cAAU;MAAEI,OAAO;MAAeC,SAAUE,EAAYF;MAASG,OAAOD;IAAE,CAAA;AAC1E,WAAO;EACT;AACF;AATsBe;","names":["loadNative","onError","core","require","requireOptionalNativeModule","stage","message","mod","e","cause","native","getNative","undefined","enableNativeCapture","opts","ok","enableCrashReporter","enableAnrWatchdog","anrThresholdMs","getPendingNativeCrash","getPendingCrashReport","purgePendingNativeCrash","purgePendingCrashReport","generateTestNativeReport","generateTestReport"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android"],
+  "ios": {
+    "modules": ["TasksSdkRnNativeModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.tasksnative.TasksSdkRnNativeModule"]
+  }
+}

package/ios/TasksSdkRnNativeModule.swift

@@ -0,0 +1,167 @@
+import ExpoModulesCore
+import CrashReporter
+
+/**
+ * Expo module that exposes PLCrashReporter to JavaScript.
+ *
+ *  - `enableCrashReporter()` installs the Mach exception + signal handler
+ *     on the first call. PLCrashReporter writes a binary `.plcrash` file to
+ *     ~/Library/Caches/com.plausiblelabs.crashreporter.data/ on death.
+ *  - `getPendingCrashReport()` returns the previous-run crash report as a
+ *     JSON object (symbolicated to addresses + load-image layout). After the
+ *     JS layer ships it, the caller invokes `purgePendingCrashReport()`.
+ *
+ * The native side never tries to POST events itself — that's the JS SDK's
+ * job. We just expose a thin window into the crash artifact.
+ */
+public class TasksSdkRnNativeModule: Module {
+  private var crashReporter: PLCrashReporter?
+
+  public func definition() -> ModuleDefinition {
+    Name("TasksSdkRnNative")
+
+    /**
+     * Install PLCrashReporter. Safe to call multiple times — the second call
+     * is a no-op. Returns `false` if installation failed (e.g. another crash
+     * reporter is already attached).
+     */
+    AsyncFunction("enableCrashReporter") { (promise: Promise) in
+      if self.crashReporter != nil {
+        promise.resolve(true)
+        return
+      }
+      // Use Mach exception server — catches everything except SIGKILL/SIGSTOP.
+      // BSD signals are caught as a fallback for the subset Mach can't see.
+      let config = PLCrashReporterConfig(
+        signalHandlerType: .mach,
+        symbolicationStrategy: .all
+      )
+      guard let reporter = PLCrashReporter(configuration: config) else {
+        promise.resolve(false)
+        return
+      }
+      do {
+        try reporter.enableAndReturnError()
+        self.crashReporter = reporter
+        promise.resolve(true)
+      } catch {
+        promise.reject("E_CRASH_REPORTER", "Failed to enable: \(error.localizedDescription)")
+      }
+    }
+
+    /**
+     * Returns the pending crash report from the previous launch as a
+     * dictionary, or `null` if none exists. The dictionary mirrors the
+     * cross-platform schema consumed by `@koderlabs/tasks-sdk-rn`.
+     */
+    AsyncFunction("getPendingCrashReport") { (promise: Promise) in
+      guard let reporter = self.crashReporter ?? PLCrashReporter.shared() else {
+        promise.resolve(nil)
+        return
+      }
+      guard reporter.hasPendingCrashReport() else {
+        promise.resolve(nil)
+        return
+      }
+      do {
+        let data = try reporter.loadPendingCrashReportDataAndReturnError()
+        let report = try PLCrashReport(data: data)
+
+        var threads: [[String: Any]] = []
+        if let reportThreads = report.threads as? [PLCrashReportThreadInfo] {
+          for thread in reportThreads {
+            var frames: [[String: Any]] = []
+            if let stackFrames = thread.stackFrames as? [PLCrashReportStackFrameInfo] {
+              for frame in stackFrames {
+                frames.append([
+                  "instructionPointer": NSNumber(value: frame.instructionPointer),
+                  "symbol": frame.symbolInfo?.symbolName ?? NSNull(),
+                ])
+              }
+            }
+            threads.append([
+              "threadNumber": NSNumber(value: thread.threadNumber),
+              "crashed": NSNumber(value: thread.crashed),
+              "frames": frames,
+            ])
+          }
+        }
+
+        var images: [[String: Any]] = []
+        if let reportImages = report.images as? [PLCrashReportBinaryImageInfo] {
+          for img in reportImages {
+            images.append([
+              "name": img.imageName ?? "",
+              "baseAddress": NSNumber(value: img.imageBaseAddress),
+              "size": NSNumber(value: img.imageSize),
+              "uuid": img.imageUUID ?? "",
+            ])
+          }
+        }
+
+        let exception: [String: Any] = report.hasExceptionInfo ? [
+          "name": report.exceptionInfo?.exceptionName ?? "",
+          "reason": report.exceptionInfo?.exceptionReason ?? "",
+        ] : [:]
+
+        let signal: [String: Any] = report.signalInfo != nil ? [
+          "name": report.signalInfo?.name ?? "",
+          "code": report.signalInfo?.code ?? "",
+          "address": NSNumber(value: report.signalInfo?.address ?? 0),
+        ] : [:]
+
+        let payload: [String: Any] = [
+          "platform": "ios",
+          "timestamp": (report.systemInfo?.timestamp ?? Date()).iso8601String(),
+          "appBundleId": report.applicationInfo?.applicationIdentifier ?? "",
+          "appVersion": report.applicationInfo?.applicationVersion ?? "",
+          "osVersion": report.systemInfo?.operatingSystemVersion ?? "",
+          "exception": exception,
+          "signal": signal,
+          "threads": threads,
+          "images": images,
+        ]
+        promise.resolve(payload)
+      } catch {
+        promise.reject("E_CRASH_LOAD", "Failed to load pending crash: \(error.localizedDescription)")
+      }
+    }
+
+    /** Delete the pending crash report so it isn't re-shipped on next launch. */
+    AsyncFunction("purgePendingCrashReport") { (promise: Promise) in
+      let reporter = self.crashReporter ?? PLCrashReporter.shared()
+      reporter?.purgePendingCrashReport()
+      promise.resolve(true)
+    }
+
+    /**
+     * Synchronously force a test crash. Wraps PLCrashReporter's built-in
+     * `generateLiveReport` so dev workflows can verify wiring without
+     * actually dying.
+     */
+    AsyncFunction("generateTestReport") { (promise: Promise) in
+      guard let reporter = self.crashReporter else {
+        promise.reject("E_NOT_ENABLED", "Call enableCrashReporter first")
+        return
+      }
+      do {
+        let data = try reporter.generateLiveReportAndReturnError()
+        let report = try PLCrashReport(data: data)
+        promise.resolve([
+          "captured": true,
+          "timestamp": (report.systemInfo?.timestamp ?? Date()).iso8601String(),
+        ])
+      } catch {
+        promise.reject("E_LIVE_REPORT", "Failed: \(error.localizedDescription)")
+      }
+    }
+  }
+}
+
+private extension Date {
+  func iso8601String() -> String {
+    let f = ISO8601DateFormatter()
+    f.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+    return f.string(from: self)
+  }
+}