fix(upgrade): remove child-process mmap probe, use direct try/catch

Compiled Bun binaries don't support the -e flag, so spawning
process.execPath -e '...' re-runs the main program instead of
evaluating the expression. This made probeMmapSafe() always return
false in production, negating the mmap optimization.

The probe was unnecessary: mmap on a temp copy is safe because the
copy is a regular file (separate inode), not a running binary.
ETXTBSY (Linux) and AMFI SIGKILL (macOS) only affect the running
binary's inode. Simplify to direct copy → mmap with try/catch
fallback to arrayBuffer().

Addresses Seer review comment on PR #344.

Author: BYK

AGENTS.md

@@ -666,7 +666,7 @@ mock.module("./some-module", () => ({
 * **Install script: BSD sed and awk JSON parsing breaks OCI digest extraction**: The install script parses OCI manifests with awk (no jq). Key trap: BSD sed \`\n\` is literal, not newline. Fix: single awk pass tracking last-seen \`"digest"\`, printing when \`"org.opencontainers.image.title"\` matches target. The config digest (\`sha256:44136fa...\`) is a 2-byte \`{}\` blob — downloading it instead of the real binary causes \`gunzip: unexpected end of file\`.
 
 <!-- lore:019cb963-cb63-722d-9365-b34336f4766d -->
-* **macOS SIGKILL on MAP\_SHARED mmap of signed Mach-O binaries**: \`Bun.mmap()\` always opens files with \`PROT\_WRITE\`/\`O\_RDWR\` regardless of the \`shared\` flag. This fails on the running binary: macOS sends uncatchable SIGKILL (AMFI rejects writable mappings on signed Mach-O), Linux returns ETXTBSY (kernel blocks opening running executables for write). The platform-conditional fix (PR #340: darwin→arrayBuffer, else→mmap) was insufficient — mmap fails on BOTH platforms. Fixed by using \`new Uint8Array(await Bun.file(oldPath).arrayBuffer())\` unconditionally in bspatch.ts. Costs ~100 MB heap for the old binary but is the only approach that works cross-platform.
+* **macOS SIGKILL on MAP\_SHARED mmap of signed Mach-O binaries**: \`Bun.mmap()\` always opens files with \`PROT\_WRITE\`/\`O\_RDWR\` regardless of the \`shared\` flag. This fails on the running binary: macOS sends uncatchable SIGKILL (AMFI rejects writable mappings on signed Mach-O), Linux returns ETXTBSY (kernel blocks opening running executables for write). Fix: copy-then-mmap — copy the running binary to a temp file, then mmap the copy (separate inode, no AMFI/ETXTBSY restrictions). Falls back to \`arrayBuffer()\` if copy/mmap fails. Do NOT use child-process probe (\`process.execPath -e ...\`) — compiled Bun binaries don't support \`-e\`, causing the child to rerun the main program.
 
 <!-- lore:019c969a-1c90-7041-88a8-4e4d9a51ebed -->
 * **Multiple mockFetch calls replace each other — use unified mocks for multi-endpoint tests**: Bun test mocking gotchas: (1) \`mockFetch()\` replaces \`globalThis.fetch\` — calling it twice replaces the first mock. Use a single unified fetch mock dispatching by URL pattern. (2) \`mock.module()\` pollutes the module registry for ALL subsequent test files. Tests using it must live in \`test/isolated/\` and run via \`test:isolated\`. (3) For \`Bun.spawn\`, use direct property assignment in \`beforeEach\`/\`afterEach\`.

src/lib/bspatch.ts

@@ -6,8 +6,7 @@
  * minimal memory usage during CLI self-upgrades:
  *
  * - Old binary: copy-then-mmap for 0 JS heap (CoW on btrfs/xfs/APFS),
- *   with child-process probe for mmap safety (macOS AMFI sends uncatchable
- *   SIGKILL on signed Mach-O), falling back to `arrayBuffer()` if unsafe
+ *   falling back to `arrayBuffer()` if copy/mmap fails
  * - Diff/extra blocks: streamed via `DecompressionStream('zstd')`
  * - Output: written incrementally to disk via `Bun.file().writer()`
  * - Integrity: SHA-256 computed inline via `Bun.CryptoHasher`
@@ -228,88 +227,38 @@ type OldFileHandle = {
   cleanup: () => void;
 };
 
-/**
- * Probe whether `Bun.mmap()` works on a file by spawning a child process.
- *
- * macOS AMFI sends uncatchable SIGKILL when a process creates a writable
- * memory mapping of a code-signed Mach-O binary — even a copy. Since
- * SIGKILL terminates the process inside the syscall (before any catch
- * block runs), we cannot detect the failure in-process.
- *
- * This probe spawns a minimal child that attempts `Bun.mmap()` on the
- * target file. If the child exits 0, mmap is safe. If it's killed
- * (SIGKILL) or exits non-zero, we fall back to `arrayBuffer()`.
- *
- * @param filePath - Path to the file to probe (should be the temp copy)
- * @returns true if mmap is safe on this file, false otherwise
- */
-async function probeMmapSafe(filePath: string): Promise<boolean> {
-  try {
-    const child = Bun.spawn(
-      [
-        process.execPath,
-        "-e",
-        `Bun.mmap(${JSON.stringify(filePath)}, { shared: false })`,
-      ],
-      { stdout: "ignore", stderr: "ignore" }
-    );
-    const exitCode = await child.exited;
-    return exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
 /**
  * Load the old binary for read access during patching.
  *
- * Strategy: copy to temp file, probe mmap safety via child process,
- * then mmap the copy if safe. This avoids `Bun.mmap()` on files that
- * would trigger uncatchable SIGKILL (macOS AMFI on signed Mach-O) while
- * keeping zero JS heap on platforms where mmap works. On CoW filesystems
- * (btrfs, xfs, APFS) the copy is a metadata-only reflink (near-instant).
+ * Strategy: copy to temp file, then try mmap on the copy. The copy is a
+ * regular file (no running process), so `Bun.mmap()` succeeds on both
+ * Linux and macOS — ETXTBSY (Linux) and AMFI SIGKILL (macOS) only affect
+ * the running binary's inode, not a copy. On CoW filesystems (btrfs, xfs,
+ * APFS) the copy is a metadata-only reflink (near-instant).
  *
- * Falls back to `Bun.file().arrayBuffer()` (~100 MB heap) if the probe
- * fails or if copy/mmap errors for any reason.
+ * Falls back to `Bun.file().arrayBuffer()` (~100 MB heap) if copy or
+ * mmap fails for any reason.
  */
 async function loadOldBinary(oldPath: string): Promise<OldFileHandle> {
   const tempCopy = join(tmpdir(), `sentry-patch-old-${process.pid}`);
   try {
     copyFileSync(oldPath, tempCopy);
 
-    // Probe mmap safety in a child process — macOS AMFI sends uncatchable
-    // SIGKILL on writable mappings of signed Mach-O, even for copies.
-    const mmapSafe = await probeMmapSafe(tempCopy);
-
-    if (mmapSafe) {
-      const data = Bun.mmap(tempCopy, { shared: false });
-      return {
-        data,
-        cleanup: () => {
-          try {
-            unlinkSync(tempCopy);
-          } catch {
-            // Best-effort cleanup — OS will reclaim on reboot
-          }
-        },
-      };
-    }
-
-    // mmap probe failed — read copy into JS heap, then clean up temp file
-    const data = new Uint8Array(await Bun.file(tempCopy).arrayBuffer());
-    try {
-      unlinkSync(tempCopy);
-    } catch {
-      // Best-effort cleanup
-    }
+    // mmap the copy — safe because it's a separate inode, not the running
+    // binary. MAP_PRIVATE avoids write-back to disk.
+    const data = Bun.mmap(tempCopy, { shared: false });
     return {
       data,
       cleanup: () => {
-        // Data is in JS heap — no temp file to clean up
+        try {
+          unlinkSync(tempCopy);
+        } catch {
+          // Best-effort cleanup — OS will reclaim on reboot
+        }
       },
     };
   } catch {
-    // Copy failed — fall back to reading original directly into JS heap
+    // Copy or mmap failed — fall back to reading into JS heap
     try {
       unlinkSync(tempCopy);
     } catch {