Restore smol-gated retain-with-limit reset for the module loader transpile arena

src/jsc/ModuleLoader.rs

@@ -55,18 +55,21 @@ impl ModuleLoader {
     /// `VirtualMachine`, so passing both would alias (PORTING.md §Forbidden).
     /// Access `module_loader` through `jsc_vm` instead.
     pub fn reset_arena(jsc_vm: &mut VirtualMachine) {
-        // PERF: this unconditionally calls `reset()`. Per
-        // `MimallocArena::reset_retain_with_limit`'s doc comment, the
-        // "mimalloc's segment cache keeps pages warm anyway" theory behind
-        // unconditional `reset()` proved wrong (purged pages get re-committed
-        // and re-zeroed each cycle), which is why the cap-gated retain exists
-        // and the other call sites use `reset_retain_with_limit(8 MiB)`.
-        // Switching to the retain-with-limit form (when not in smol mode) is
-        // a perf-sensitive change that
-        // needs benchmarking (transpile arena RSS vs cycle cost), so it is
-        // tracked as a dedicated work order rather than changed inline.
+        let smol = jsc_vm.smol;
         if let Some(arena) = jsc_vm.module_loader.transpile_source_code_arena.as_mut() {
-            arena.reset();
+            if smol {
+                // --smol prioritizes RSS: always destroy, retain nothing.
+                arena.reset();
+                bun_core::scoped_log!(ModuleLoader, "reset_arena: free_all");
+            } else {
+                let retained = arena.reset_retain_with_limit(8 * 1024 * 1024);
+                // Asserted by load-same-js-file-a-lot.test.ts.
+                bun_core::scoped_log!(
+                    ModuleLoader,
+                    "reset_arena: {}",
+                    if retained { "retained" } else { "recycled" }
+                );
+            }
         }
     }
 }

src/runtime/dispatch.rs

@@ -1188,6 +1188,20 @@
             for_each_fs_async_op!(__fs_destroy);
             true
         }
+        // Deferred napi finalizers enqueued by a GC that the loop never got
+        // to drain. Running the addon callback this late is not safe (it may
+        // call back into JS), so drop the box without dispatching — same
+        // policy as `NapiFinalizerTask::schedule`'s shutdown branch. The drop
+        // releases the `Ref<NapiEnv>` while the env is still alive (we run
+        // before `destructOnExit`); the addon's external data is reclaimed by
+        // the OS at process exit.
+        task_tag::NapiFinalizerTask => {
+            // SAFETY: `task.ptr` is the `Box<NapiFinalizerTask>` from
+            // `NapiFinalizerTask::schedule` (`heap::into_raw`); the loop will
+            // never dispatch it, so we hold the sole reference.
+            drop(unsafe { bun_core::heap::take(task.ptr.cast::<NapiFinalizerTask>()) });
+            true
+        }
         // Re-queued by the caller; the box stays reachable from the
         // static-rooted VM. Dispatching the type-erased `AnyTask` callback
         // is not generally safe at shutdown (e.g. `AsyncModule::on_done`,

test/js/bun/resolve/load-same-js-file-a-lot.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from "bun:test";
-import { isASAN, isDebug } from "harness";
+import { bunEnv, bunExe, isASAN, isDebug, tempDir } from "harness";
 
 const asanIsSlowMultiplier = isASAN ? 0.2 : 1;
 const count = Math.floor(10000 * asanIsSlowMultiplier);
@@ -34,6 +34,101 @@ test(
   isDebug || isASAN ? 20_000 : 5000,
 );
 
+// ModuleLoader::reset_arena: --smol destroys the transpile arena every cycle;
+// otherwise it retains the warm heap under an 8 MiB cap and recycles when over.
+// The over-cap branch is only reachable via the parse-error path (success
+// resets the arena before parking it), hence the oversized broken modules.
+// Debug builds assert the branch taken via the BUN_DEBUG_ModuleLoader log.
+for (const smol of [false, true]) {
+  test(
+    `transpile arena reset policy (${smol ? "--smol" : "default"})`,
+    async () => {
+      const iters = isASAN || isDebug ? 50 : 200;
+      const brokenCount = isASAN || isDebug ? 1 : 2;
+
+      // 150k statements pushes the transpile arena well past the 8 MiB cap.
+      const bigLines: string[] = [];
+      for (let i = 0; i < 150_000; i++) {
+        bigLines.push(`const v${i} = ${i};`);
+      }
+      const bigValid = bigLines.join("\n") + "\nexport const sum = v0 + v149999;";
+      // Syntax error at the end so the full AST is in the arena before failing.
+      const bigBroken = bigLines.join("\n") + "\n}";
+
+      const files: Record<string, string> = {
+        "big_valid.ts": bigValid,
+        "driver.ts": `
+          let total = 0;
+          let caught = 0;
+          for (let i = 0; i < ${iters}; i++) {
+            // require(), not import(): dynamic import skips the synchronous
+            // arena reset (concurrent transpiler store).
+            const m = require("./small_" + i + ".ts");
+            total += m.value;
+            if (i % 10 === 0) Bun.gc(true);
+          }
+          for (let i = 0; i < ${brokenCount}; i++) {
+            try {
+              require("./big_broken_" + i + ".ts");
+            } catch {
+              caught++;
+            }
+            Bun.gc(true);
+          }
+          total += require("./big_valid.ts").sum;
+          Bun.gc(true);
+          console.log("total=" + total + " caught=" + caught);
+        `,
+      };
+      for (let i = 0; i < iters; i++) {
+        files[`small_${i}.ts`] = `export const value: number = 1;\n`;
+      }
+      for (let i = 0; i < brokenCount; i++) {
+        files[`big_broken_${i}.ts`] = bigBroken;
+      }
+
+      using dir = tempDir("transpile-arena-reset", files);
+
+      const cmd = [bunExe()];
+      if (smol) cmd.push("--smol");
+      cmd.push("driver.ts");
+
+      await using proc = Bun.spawn({
+        cmd,
+        // The scoped log is compiled out of release builds.
+        env: isDebug ? { ...bunEnv, BUN_DEBUG_ModuleLoader: "1" } : bunEnv,
+        cwd: String(dir),
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+      expect(stdout).toContain(`total=${iters + 149999} caught=${brokenCount}`);
+      if (isDebug) {
+        const logs = stdout + stderr;
+        const occurrences = (needle: string) => logs.split(needle).length - 1;
+        if (smol) {
+          expect(occurrences("reset_arena: free_all")).toBeGreaterThanOrEqual(iters + brokenCount);
+          expect(occurrences("reset_arena: retained")).toBe(0);
+          expect(occurrences("reset_arena: recycled")).toBe(0);
+        } else {
+          // Each oversized parse failure must trip the over-cap recycle; if the
+          // broken fixture stops clearing the cap, this fails rather than
+          // silently losing branch coverage.
+          expect(occurrences("reset_arena: retained")).toBeGreaterThanOrEqual(iters);
+          expect(occurrences("reset_arena: recycled")).toBeGreaterThanOrEqual(brokenCount);
+          expect(occurrences("reset_arena: free_all")).toBe(0);
+        }
+      } else {
+        expect({ stderr, exitCode }).toEqual({ stderr: "", exitCode: 0 });
+      }
+      expect(exitCode).toBe(0);
+    },
+    isDebug || isASAN ? 120_000 : 30_000,
+  );
+}
+
 test(`load the same empty JS file ${count} times`, async () => {
   const prev = Bun.unsafe.gcAggressionLevel();
   Bun.unsafe.gcAggressionLevel(0);

test/js/bun/util/inspect-error-leak.test.js

@@ -22,5 +22,8 @@ test("Printing errors does not leak", () => {
   console.log(`RSS increased by ${diff} MB`);
   // ASAN's free quarantine (default 256 MB) plus redzones and glibc page
   // retention inflate RSS even when nothing is leaking.
-  expect(diff, `RSS grew by ${diff} MB after ${perBatch * repeat} iterations`).toBeLessThan(isASAN ? 400 : 10);
+  // Bun.inspect(Error) reaches ModuleLoader::reset_arena via the ZigException
+  // stack-remap path, so the 8 MiB retain-with-limit arena policy raises the
+  // measured delta.
+  expect(diff, `RSS grew by ${diff} MB after ${perBatch * repeat} iterations`).toBeLessThan(isASAN ? 400 : 20);
 }, 10_000);