[sentry-junior]

Follow-up to #1810. That PR split the standalone binary into a CLI asset and a completion asset with a V8 code cache. The npm package still shipped the CLI and the library as one ~7 MB index.cjs, so every sentry run and every require("sentry") compiled all of it.

Now the npm package, the SDK, and the binary all ship as code-split chunks. One build helper and one runtime loader produce and load them.

Build: script/lib/split-bundle.ts, shared by bundle.ts and build.ts

• esbuild only splits ESM, so the CommonJS build takes two passes. Pass 1 is ESM with splitting. Pass 2 converts each chunk to CommonJS without bundling. Pass 2 reads pass 1's sourcemaps, so the final maps point at src/ (checked with trace-mapping).
• Every import() starts a chunk (each route in route-loaders.ts). So does every lazy _require() that require-alias rewrites: telemetry, cli-highlight, the --fields parser, and the WASM SQLite driver. Each of these becomes a lazy-*.cjs entry.
• import("./chunk-X.cjs") is rewritten to a require-based __load() helper. That way a chunk loads through the same loader as its parent. Other import() calls stay native: builtins, and the Ink sidecar, which uses top-level await.
• npm: cli.cjs and index.cjs share their chunks. index.mjs is split the same way and keeps the zlib shim. complete.cjs stays one file. package.json#files now uses dist/*.cjs and dist/*.mjs.
• Binary: the same chunks, each embedded as a SEA asset under dist-build/<chunk>.
• script/lib/chunk-build.ts holds the shared steps after the build: debug IDs and sourcemap upload for every chunk, the build hash, and bundling the main script. Each chunk registers its own debug ID through the injected snippet. The __SENTRY_DEBUG_ID__ placeholder in constants.ts is now dead, so it is removed.

Runtime: src/chunk-main.ts + src/lib/chunk-loader.ts

These replace sea-main.ts and sea-chunk.ts.

• The same main script runs as dist/bin.cjs (npm) and as the SEA main script. It runs cli.cjs or complete.cjs.
• The loader resolves require("./chunk-*.cjs") itself. It reads each chunk from a file or a SEA asset. It keeps a V8 code cache per chunk under <config dir>/cache/code/<build>-<platform>-<v8 tag>/, writes it on exit, keeps the 3 newest builds, and deletes the cache files left by perf(cli): split the SEA binary into a bootstrap and cached chunks #1810.
• Node 20/21 load the chunks natively, without a code cache. On Node 20, a script compiled from a code cache loses its import() callback (ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING). I hit this with the packed bin on Node 20.20.2. There is now a regression test for import() from a cached chunk.

SDK

• index.ts no longer imports the CLI runner. _cli is gone, because bin.cjs runs cli.cjs.
• SDK calls load only the routes they run, through src/sdk-app.ts. It works like app-for-args.ts, except that the loaded routes accumulate so concurrent calls can't drop each other's routes.
• cli-startup.test.ts now asserts that index.ts, sdk-app.ts, and app-for-args.ts load no command.

Not done: a consumer's bundler still can't drop unused commands at build time. createSentrySDK() returns one object that references every command. The chunks also have real top-level side effects (module init, registrations), so I did not set sideEffects: false. For now, "tree-shakeable" means runtime laziness: an app loads only what it calls.

Measurements (Node 22, this sandbox; medians, noisy)

Warm code cache, SENTRY_CLI_NO_TELEMETRY=1, 21 runs:

command	npm main	npm split	SEA main	SEA split
--version	530 ms	289 ms	285 ms	279 ms
issue list --help	426 ms	226 ms	239 ms	237 ms
org list --help	456 ms	234 ms	270 ms	264 ms

• Cold code cache, issue list --help: npm 431 → 372 ms, SEA 472 → 363 ms.
• Max RSS, issue list --help: npm 152 → 104 MB, SEA 130 → 105 MB.
• With a warm cache, the binary is about the same speed as before. perf(cli): split the SEA binary into a bootstrap and cached chunks #1810 already cached its whole bundle. Here the binary gains less memory use, a faster cold start, and the same pipeline as npm.
• SDK: require("sentry") reads 6.8 MB on main and 79 KB here (~229 → 33 ms process time). import() of index.mjs takes ~289 → 43 ms. sdk.org.list() loads 1.66 MB in 80 files.
• --version and help still load every route on main. perf(cli): Skip loading commands for --version and leading global flags #1826 fixes that, so the two PRs add up.

Verification

• tsc, root pnpm run lint, and ci:policy pass.
• CLI unit suite: 13,069 pass. 11 fail, and all of them fail the same way on main in this sandbox: 6 chmod/EACCES tests, plus 5 errors/oauth/auto-login-host-guard message tests.
• The full e2e suite passes against the npm bin (SENTRY_CLI_BINARY=dist/bin.cjs, 207 tests) and against a linux-x64 SEA built with build.ts --single (179 tests).
• New tests:
  • the loader (chunk graph, stack positions, cache reuse/reject/prune, legacy cleanup, import() with and without a cache, Node 20 gate)
  • sdk-app (partial, accumulated, concurrent, full tree)
  • e2e: __complete reads no CLI chunk, and issue list --help reads under half of the chunks
  • npm pack contains every chunk and no sourcemap
  • the zlib link check now covers every .mjs chunk
• On Node 20.20.2, I ran the packed bin (fallback path) and both library formats by hand.

via @BYK.

--

View Session in Sentry

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment

Project	Deployment	Actions	Updated
sentry-local	Skipped		Nov 3, 2026 9:57am UTC

[BYK]

Are we still compatible with Bun btw?

[sentry-junior]

Re: Bun — yes. I tested this branch's npm build on Bun 1.4.4 (it reports Node 26 compat):

• CLI (bun dist/bin.cjs): --version, help, issue list --help, auth status (gives the expected not-authenticated error) and __complete all behave the same as on Node.
• Code cache: the chunk loader's vm.Script path runs on Bun. Bun writes its caches to a separate directory, because Bun's cachedDataVersionTag() differs from Node's, so the two never read each other's caches. On a warm run Bun doesn't rewrite them. Timing (issue list --help, warm) is about the same as Bun loading the chunks natively, ~330 ms vs ~400 ms.
• SDK (require of dist/index.cjs and import of dist/index.mjs): run("--version"), three concurrent typed calls (each gives the expected SentryError), and run("help"), which loads the full tree, all work.

The standalone binary embeds Node, so Bun doesn't apply to it. There's no Bun job in CI, and packages/cli/AGENTS.md says the repo is Node-only, so I didn't add one.