@akanjs/devkit 3.0.0-beta.25 → 3.0.0-beta.27

package/frontendBuild/csrDevResolver.ts

@@ -15,6 +15,12 @@ interface PrepassMetafile {
   inputs: Record<string, { imports: MetafileImport[] }>;
 }
 
+interface BrowserMap {
+  /** What the `browser` object maps to `false`: an empty module in a browser build. */
+  offFiles: Set<string>;
+  offNames: Set<string>;
+}
+
 export interface CsrDevResolverOptions {
   paths: CsrDevPaths;
   context: CsrDevContext;
@@ -22,6 +28,8 @@ export interface CsrDevResolverOptions {
   resolution?: Record<string, Record<string, string>>;
   /** Specifiers per importer id whose recorded resolution came from Bun's runtime resolver, not the browser build. */
   runtimeResolved?: Record<string, string[]>;
+  /** When this process began: a package installed after it is one Bun's resolver here has not seen. */
+  startedAt?: number;
 }
 
 //* Resolution comes from a plain browser build: Bun's runtime resolver ignores the `browser` condition and picks Node
@@ -34,10 +42,22 @@ export class CsrDevResolver {
   readonly #resolution = new Map<string, Map<string, string>>();
   readonly #fallbacks = new Set<string>();
   readonly #runtimeResolved = new Map<string, Set<string>>();
+  readonly #browserMaps = new Map<string, BrowserMap | null>();
+  /** Files a browser build loaded, so every import they make has its browser resolution recorded. */
+  readonly #loaded = new Set<string>();
+  readonly #startedAt: number;
   #prepassDone = false;
 
-  constructor({ paths, context, entryFiles, resolution = {}, runtimeResolved = {} }: CsrDevResolverOptions) {
+  constructor({
+    paths,
+    context,
+    entryFiles,
+    resolution = {},
+    runtimeResolved = {},
+    startedAt = Date.now() - process.uptime() * 1000,
+  }: CsrDevResolverOptions) {
     this.#paths = paths;
+    this.#startedAt = startedAt;
     this.#context = context;
     this.#entryFiles = entryFiles;
     for (const [importer, specifiers] of Object.entries(runtimeResolved))
@@ -73,9 +93,52 @@ export class CsrDevResolver {
       optimizeImports: this.#context.optimizeImports,
       plugins: [PagesBundleBuilder.createCssStubPlugin()],
     });
-    const { inputs } = result.metafile as unknown as PrepassMetafile;
+    this.#record((result.metafile as unknown as PrepassMetafile).inputs);
+    this.#prepassDone = true;
+  }
+
+  //? The browser build drops a side-effect-free barrel's unused re-exports without loading them, yet the registry
+  //? compiles every file an import names. Such a file's own imports are resolved by a browser build of its own, one
+  //? level deep, not by the runtime resolver's Node conditions (vfile's `#minpath` would reach `node:path`).
+  async cover(files: string[]): Promise<void> {
+    if (!this.#prepassDone) return;
+    const pending = files.filter((file) => CsrDevPaths.isScript(file) && !this.#loaded.has(file));
+    if (pending.length === 0) return;
+    for (const file of pending) this.#loaded.add(file);
+    const entries = new Set(pending);
+    const result = await Bun.build({
+      entrypoints: pending,
+      target: "browser",
+      metafile: true,
+      throw: false,
+      external: [...(this.#context.externals ?? [])],
+      env: "AKAN_PUBLIC_*",
+      define: this.#context.define,
+      plugins: [
+        {
+          name: "akan-csr-cover",
+          //? What an entry imports is resolved, never parsed: a CommonJS stub, since an empty ESM module fails a named
+          //? import ("No matching export") and a failed build hands back no metafile at all.
+          setup: (build) => {
+            build.onLoad({ filter: /.*/ }, (args) =>
+              entries.has(CsrDevPaths.realpath(args.path))
+                ? undefined
+                : { contents: "module.exports = {};", loader: "js" },
+            );
+          },
+        },
+      ],
+    });
+    //? Left unrecorded when the build fails: those imports keep the runtime resolver's answer, as before.
+    if (result.metafile) this.#record((result.metafile as unknown as PrepassMetafile).inputs, entries);
+  }
+
+  #record(inputs: PrepassMetafile["inputs"], only?: Set<string>): void {
     for (const [input, { imports }] of Object.entries(inputs)) {
       const importer = CsrDevPaths.realpath(path.resolve(input));
+      if (only && !only.has(importer)) continue;
+      //? A re-export the build tree-shook keeps no specifier, so its file is resolved again as an entry of its own.
+      if (imports.every((record) => record.original)) this.#loaded.add(importer);
       for (const record of imports) {
         if (!record.original) continue;
         if (record.external) {
@@ -89,13 +152,14 @@ export class CsrDevResolver {
         this.#runtimeResolved.get(importer)?.delete(record.original);
       }
     }
-    this.#prepassDone = true;
   }
 
   resolve(importer: string, specifier: string, kind: "import" | "require" = "import"): string | null {
     if (this.#isInlineSpecifier(specifier)) return CsrDevResolver.inline;
+    const disabled = this.#disabledInBrowser(importer, specifier, kind);
+    if (disabled) return disabled;
     const known = this.#resolution.get(importer)?.get(specifier);
-    const usable = known && this.#stillAnswers(importer, specifier, known) ? known : null;
+    const usable = known && this.#stillAnswers(importer, specifier, known, kind) ? known : null;
     const target = usable ?? this.#resolveUnknown(importer, specifier, kind);
     if (target === null || CsrDevPaths.isStub(target)) return target;
     if (!CsrDevPaths.isScript(target)) return CsrDevResolver.inline;
@@ -103,14 +167,18 @@ export class CsrDevResolver {
     return target;
   }
 
-  //? A record stands until its file is gone, or until a file created beside the folder it went into takes the import
-  //? over (`Foo.tsx` next to `Foo/index.tsx`), as it does for Bun and every other build. Nothing else overturns it: the
-  //? prepass chose between sibling files and package fields as Bun does, which a disk lookup would only approximate.
-  #stillAnswers(importer: string, specifier: string, known: string): boolean {
+  //? A relative record in app code stands while the disk still resolves it to the same file, as Bun would: a sibling
+  //? with a stronger extension (`x.tsx` beside `x.ts`), a file beside the folder it went into, or a record a CommonJS
+  //? re-export folded onto another file (`./a` → `x.js`) resolves anew. A package's files, and app code under a
+  //? package.json that maps files with a `browser` object, keep the prepass's answer, which a disk lookup would only
+  //? approximate.
+  #stillAnswers(importer: string, specifier: string, known: string, kind: "import" | "require"): boolean {
     if (CsrDevPaths.isStub(known)) return true;
     if (!fs.existsSync(known)) return false;
     if (!specifier.startsWith(".") || CsrDevPaths.isVendorFile(importer)) return true;
-    return !CsrDevPaths.isShadowed(path.resolve(path.dirname(importer), specifier), known);
+    if (this.#hasBrowserMap(path.dirname(importer))) return true;
+    const onDisk = CsrDevPaths.resolveRelative(path.dirname(importer), specifier, kind);
+    return onDisk !== null && CsrDevPaths.realpath(onDisk) === known;
   }
 
   isRegistryModule(file: string): boolean {
@@ -123,6 +191,59 @@ export class CsrDevResolver {
     });
   }
 
+  //? `false` in a package's `browser` object is an empty module to a browser build (object-inspect's
+  //? `./util.inspect.js`, which requires `util`). Its record carries no specifier, so the field is read here.
+  #disabledInBrowser(importer: string, specifier: string, kind: "import" | "require"): string | null {
+    const map = this.#browserMapOf(path.dirname(importer));
+    if (!map || (map.offFiles.size === 0 && map.offNames.size === 0)) return null;
+    if (!specifier.startsWith(".") && !path.isAbsolute(specifier))
+      return map.offNames.has(specifier) ? `${CsrDevPaths.emptyStubPrefix}${specifier}` : null;
+    const target = CsrDevPaths.resolveRelative(path.dirname(importer), specifier, kind);
+    return target && map.offFiles.has(CsrDevPaths.realpath(target))
+      ? `${CsrDevPaths.emptyStubPrefix}${this.#paths.idOf(target)}`
+      : null;
+  }
+
+  #hasBrowserMap(dir: string): boolean {
+    return this.#browserMapOf(dir) !== null;
+  }
+
+  #browserMapOf(dir: string): BrowserMap | null {
+    const cached = this.#browserMaps.get(dir);
+    if (cached !== undefined) return cached;
+    const pkgFile = path.join(dir, "package.json");
+    const parent = path.dirname(dir);
+    let map: BrowserMap | null = null;
+    if (fs.existsSync(pkgFile)) {
+      try {
+        const browser = (JSON.parse(fs.readFileSync(pkgFile, "utf8")) as { browser?: unknown }).browser;
+        if (typeof browser === "object" && browser !== null) {
+          const off = Object.entries(browser)
+            .filter(([, target]) => target === false)
+            .map(([key]) => key);
+          const files = off
+            .filter((key) => key.startsWith("."))
+            .map((key) => CsrDevPaths.resolveRelative(dir, key))
+            .filter((file): file is string => !!file);
+          map = {
+            offFiles: new Set(files.map((file) => CsrDevPaths.realpath(file))),
+            offNames: new Set(off.filter((key) => !key.startsWith("."))),
+          };
+        }
+      } catch {
+        // An unreadable package.json maps nothing; Bun's build fails on it anyway.
+      }
+    } else if (parent !== dir) map = this.#browserMapOf(parent);
+    this.#browserMaps.set(dir, map);
+    return map;
+  }
+
+  /** A module that left the graph takes its records with it. */
+  forget(importer: string): void {
+    this.#resolution.delete(importer);
+    this.#runtimeResolved.delete(importer);
+  }
+
   serializeRuntimeResolved(): Record<string, string[]> {
     return Object.fromEntries(
       [...this.#runtimeResolved]
@@ -154,7 +275,7 @@ export class CsrDevResolver {
     const cannotResolve = () => new Error(`[csr-dev] cannot resolve "${specifier}" from ${this.#paths.idOf(importer)}`);
     if (relative) {
       const onDisk =
-        CsrDevPaths.resolveOnDisk(path.resolve(path.dirname(importer), specifier), kind) ??
+        CsrDevPaths.resolveRelative(path.dirname(importer), specifier, kind) ??
         CsrDevResolver.#onDisk(CsrDevPaths.tryResolve(specifier, path.dirname(importer)));
       if (!onDisk) throw cannotResolve();
       return CsrDevPaths.realpath(onDisk);
@@ -165,13 +286,21 @@ export class CsrDevResolver {
     if (sibling) return sibling;
     const resolved = CsrDevPaths.tryResolve(specifier, path.dirname(importer));
     const moved = resolved !== null && path.isAbsolute(resolved) && !fs.existsSync(resolved);
+    //? Bun keeps a process's node_modules listings: a package installed while the builder runs (`bun add`) resolves only
+    //? in a fresh process, so one installed since this process began goes to a worker. Any other miss, a subpath typo
+    //? of a package installed long ago included, fails here as the worker would.
+    const installed =
+      resolved === null && CsrDevPaths.installedSince(specifier, path.dirname(importer), this.#startedAt);
     if (!this.#prepassDone || moved) {
       //? A specifier no resolver finds in the user's own code is a typo, failed here like a missing relative file: the
       //? resolution build a worker would run for it fails the same way. A package's `browser` field may map one away.
-      if (resolved === null && !CsrDevPaths.isVendorFile(importer)) throw cannotResolve();
+      if (resolved === null && !installed && !CsrDevPaths.isVendorFile(importer)) throw cannotResolve();
       return null;
     }
-    if (!resolved) throw cannotResolve();
+    if (!resolved) {
+      if (installed) return null;
+      throw cannotResolve();
+    }
     if (!path.isAbsolute(resolved)) return `${CsrDevPaths.stubPrefix}${specifier}`;
     this.#fallbacks.add(specifier);
     this.#runtimeResolved.set(importer, (this.#runtimeResolved.get(importer) ?? new Set<string>()).add(specifier));

package/frontendBuild/csrDevTypes.ts

@@ -18,6 +18,8 @@ export interface CsrDevGraph {
   /** Specifiers per importer id `resolution` holds from Bun's runtime resolver rather than the browser build. */
   runtimeResolved?: Record<string, string[]>;
   pending: string[];
+  /** A build worker's failed round: the ids it built, and the files it failed in or named, by hash. */
+  failed?: { roots: string[]; files: Record<string, string> };
   /** The stamp of the signal and dictionary sources the last whole build inlined; see `RegistryMetadataFingerprint`. */
   metadata?: string;
 }

package/frontendBuild/devRegistryBundler.ts

@@ -81,12 +81,25 @@ export abstract class DevRegistryBundler {
     return update;
   }
 
-  /** Of these roots outside the graph, the ones something still reaches (an entry, a module's import): those stay pending. */
+  /** Of these files, the ones the registry still reaches from its roots through imports: those it keeps building. */
   async wantedRoots(files: string[], graph: CsrDevGraph): Promise<Set<string>> {
-    const reached = new Set([...Object.values(graph.entries), ...Object.values(graph.modules).flatMap((m) => m.deps)]);
+    const reached = await this.reachable(graph);
     return new Set(files.filter((file) => reached.has(this.paths.idOf(file))));
   }
 
+  /** The ids its roots reach through imports, the refresh runtime included. */
+  async reachable(graph: CsrDevGraph): Promise<Set<string>> {
+    const roots = await this.rootFiles(Object.values(graph.entries).map((id) => this.paths.fileOf(id)));
+    const reached = new Set<string>();
+    const stack = [graph.refresh, ...roots.map((file) => this.paths.idOf(file))];
+    for (let id = stack.pop(); id !== undefined; id = stack.pop()) {
+      if (reached.has(id)) continue;
+      reached.add(id);
+      stack.push(...(graph.modules[id]?.deps ?? []));
+    }
+    return reached;
+  }
+
   async holds(files: string[]): Promise<boolean> {
     const graph = await this.writer.readJson<CsrDevGraph>("graph.json");
     return graph !== null && files.every((file) => graph.modules[this.paths.idOf(file)] !== undefined);
@@ -166,7 +179,9 @@ export abstract class DevRegistryBundler {
         deps: module.deps.map((dep) => (CsrDevPaths.isStub(dep) ? dep : this.paths.idOf(dep))),
         ...(module.helpers ? { helpers: module.helpers.hash } : {}),
       };
-    graph.pending = [];
+    //? Only what this round compiled leaves pending: a root another route's check failed on stays for its retry.
+    const compiledIds = new Set(compiled.map((module) => module.id));
+    graph.pending = graph.pending.filter((id) => !compiledIds.has(id));
     graph.resolution = resolver.serialize();
     graph.runtimeResolved = resolver.serializeRuntimeResolved();
   }

package/frontendBuild/ssrDevBundler.ts

@@ -8,7 +8,7 @@ import { bundleDefine } from "./bundleDefine";
 import type { ClientEntryDiscovery } from "./clientBuildTypes";
 import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
 import { CsrDevPaths } from "./csrDevPaths";
-import type { CsrDevContext, CsrDevGraph } from "./csrDevTypes";
+import type { CsrDevContext } from "./csrDevTypes";
 import { DevRegistryBundler } from "./devRegistryBundler";
 import { VENDOR_SPECIFIERS } from "./vendorSpecifiers";
 
@@ -16,7 +16,7 @@ import { VENDOR_SPECIFIERS } from "./vendorSpecifiers";
 //* (the app's client runtime) and every `"use client"` entry; React and the akanjs vendor facets stay the import map's,
 //* so the page keeps one React and one store registry.
 export class SsrDevBundler extends DevRegistryBundler {
-  static readonly #formatVersion = 1;
+  static readonly #formatVersion = 2;
   static readonly bootstrapKey = "";
   readonly reloadsOnEntryChange = false;
   #discovery: ClientEntryDiscovery | null = null;
@@ -79,12 +79,6 @@ export class SsrDevBundler extends DevRegistryBundler {
     return this.#discovery;
   }
 
-  override async wantedRoots(files: string[], graph: CsrDevGraph): Promise<Set<string>> {
-    const entries = new Set(await this.clientEntries());
-    const reached = await super.wantedRoots(files, graph);
-    return new Set(files.filter((file) => reached.has(file) || entries.has(CsrDevPaths.realpath(file))));
-  }
-
   protected async rootFiles(entryFiles: string[]): Promise<string[]> {
     return [...entryFiles, ...(await this.clientEntries())];
   }

package/incrementalBuilder/incrementalBuilder.host.test.ts

@@ -1,4 +1,8 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { CSR_DEV_PATCHING_MARKER, SSR_DEV_DIRNAME } from "akanjs/server/hmr/csrDevManifest";
 import { MemoryLimit } from "akanjs/server/memoryLimit";
 import { IncrementalBuilderHost } from "./incrementalBuilder.host";
 
@@ -172,6 +176,36 @@ describe("IncrementalBuilderHost", () => {
     host.stop();
     expect(host.recycle("after stop")).toBe(false);
   });
+
+  test("a patcher a crash turned off stays off in the host that replaces this one", async () => {
+    const cwdPath = await mkdtemp(path.join(os.tmpdir(), "akan-builder-patcher-"));
+    try {
+      const spawns = mockSpawns();
+      const app = { cwdPath } as never;
+      const host = new IncrementalBuilderHost({ app, entry: "/tmp/builder.ts", env: {}, onMessage: () => undefined });
+      host.start();
+      spawns[0]?.options.ipc?.({ type: "builder-ready" });
+      const marker = path.join(cwdPath, ".akan/artifact", SSR_DEV_DIRNAME, CSR_DEV_PATCHING_MARKER);
+      await Bun.write(marker, "");
+      spawns[0]?.options.onExit?.();
+      await wait(1_050);
+      expect(spawns[1]?.options.env?.AKAN_DEV_CSR_PATCHER).toBe("off");
+      expect(host.patcherOff).toBe(true);
+      host.stop();
+      const next = new IncrementalBuilderHost({
+        app,
+        entry: "/tmp/builder.ts",
+        env: {},
+        onMessage: () => undefined,
+        patcherOff: host.patcherOff,
+      });
+      next.start();
+      expect(spawns[2]?.options.env?.AKAN_DEV_CSR_PATCHER).toBe("off");
+      next.stop();
+    } finally {
+      await rm(cwdPath, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("IncrementalBuilderHost.maxRssBytes", () => {

package/incrementalBuilder/incrementalBuilder.host.ts

@@ -30,6 +30,8 @@ interface IncrementalBuilderHostOptions {
   onMessage: (message: BuilderMessage) => void;
   /** Required with `stdio: "pipe"` (an undrained pipe blocks the builder); receives decoded chunks, not lines. */
   onOutput?: (kind: "stdout" | "stderr", text: string) => void;
+  /** Carried over from the host this one replaces: a patcher a crash turned off stays off. */
+  patcherOff?: boolean;
 }
 
 /** `recycling`: the builder finishes accepted work but refuses new requests; hold them for the replacement. */
@@ -73,17 +75,29 @@ export class IncrementalBuilderHost {
   // its own exit, so an unanswered page request would spin forever.
   readonly #inFlight = new Map<number, "build-route" | "build-csr">();
   #startOptions: IncrementalBuilderStartOptions = {};
-  constructor({ app, entry, env, stdio = "inherit", onMessage, onOutput }: IncrementalBuilderHostOptions) {
+  constructor({
+    app,
+    entry,
+    env,
+    stdio = "inherit",
+    onMessage,
+    onOutput,
+    patcherOff = false,
+  }: IncrementalBuilderHostOptions) {
     this.app = app;
     this.entry = entry;
     this.env = env;
     this.#stdio = stdio;
     this.#onMessage = onMessage;
     this.#onOutput = onOutput ?? null;
+    this.#patcherOff = patcherOff;
   }
   get status() {
     return this.#status;
   }
+  get patcherOff(): boolean {
+    return this.#patcherOff;
+  }
   /** For reading RSS between builds: the builder's own metrics sample the post-work peak, stale once arenas return. */
   get pid(): number | null {
     return this.#proc?.pid ?? null;
@@ -292,7 +306,8 @@ export class IncrementalBuilderHost {
     {
       stdio = "inherit",
       onOutput,
-    }: { stdio?: DevStdioMode; onOutput?: (kind: "stdout" | "stderr", text: string) => void } = {},
+      patcherOff = false,
+    }: Pick<IncrementalBuilderHostOptions, "stdio" | "onOutput" | "patcherOff"> = {},
   ) {
     const candidates = [
       path.join(app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
@@ -305,7 +320,7 @@ export class IncrementalBuilderHost {
     ];
     for (const c of candidates)
       if (await Bun.file(c).exists())
-        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput });
+        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput, patcherOff });
     throw new Error(`[cli] frontend builder entry not found; looked in: ${candidates.join(", ")}`);
   }
 }

package/incrementalBuilder/incrementalBuilder.proc.test.ts

@@ -77,7 +77,7 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
       error: expect.stringContaining(reason),
     });
     expect(messages.find((message) => message.type === "build-status")).toMatchObject({
-      data: { generation: 6, phase: "route", ok: false, message: expect.stringContaining(reason) },
+      data: { generation: 6, phase: "route", ok: false, message: expect.stringContaining(reason), scope: "page:/" },
     });
     expect(log).toContain(reason);
   }, 30_000);
@@ -148,6 +148,67 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
     }
   }, 60_000);
 
+  test("a route build's check whose own worker is killed is tried again after the crash window", async () => {
+    const { root } = track(await createTempApp("demo", path.join(import.meta.dir, "..", "local")));
+    const appDir = path.join(root, "apps/demo");
+    const runs = path.join(root, "ssr-runs.log");
+    // The boot build succeeds, the route check's worker is killed, and the retry after the window succeeds.
+    await writeText(
+      path.join(root, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      `import fs from "node:fs";
+const { generation, needs } = JSON.parse(process.argv[2]);
+if (needs.includes("ssr")) {
+  fs.appendFileSync(${JSON.stringify(runs)}, Date.now() + "\\n");
+  if (fs.readFileSync(${JSON.stringify(runs)}, "utf8").trim().split("\\n").length === 2) process.exit(1);
+}
+process.send({ type: "build-batch-result", data: { generation, errors: {}, artifact: {}, optimizedFonts: { css: "", files: [] } } });
+`,
+    );
+    const page = path.join(appDir, "page/_index.tsx");
+    await writeText(page, 'import { Card } from "../ui/Card";\nexport default Card;\n');
+    await writeText(path.join(appDir, "ui/Card.tsx"), '"use client";\nexport const Card = () => null;\n');
+
+    const messages: BuilderMessage[] = [];
+    const proc = Bun.spawn(["bun", path.join(import.meta.dir, "incrementalBuilder.proc.ts")], {
+      cwd: appDir,
+      env: {
+        ...process.env,
+        AKAN_WORKSPACE_ROOT: root,
+        AKAN_PUBLIC_APP_NAME: "demo",
+        AKAN_PUBLIC_REPO_NAME: "repo",
+        AKAN_PUBLIC_SERVE_DOMAIN: "localhost",
+        AKAN_PUBLIC_ENV: "local",
+        AKAN_WATCH: "0",
+      },
+      stdio: ["ignore", "ignore", "ignore"],
+      serialization: "advanced",
+      ipc: (message: BuilderMessage) => {
+        messages.push(message);
+      },
+    });
+    const ssrRuns = async () =>
+      (await Bun.file(runs).exists()) ? (await Bun.file(runs).text()).trim().split("\n").map(Number) : [];
+    try {
+      await until(proc, "boot-armed", () => messages.some((message) => message.type === "boot-armed"));
+      proc.send({
+        type: "build-route",
+        id: 1,
+        routeId: "page:/",
+        seeds: [page],
+        knownEntries: [],
+        generation: 3,
+      } satisfies BuilderReq);
+      await until(proc, "build-route-res", () => messages.some((message) => message.type === "build-route-res"));
+      const deadline = Date.now() + 20_000;
+      while ((await ssrRuns()).length < 3 && Date.now() < deadline) await wait(100);
+      const [, killed = 0, retried = 0] = await ssrRuns();
+      expect(retried - killed).toBeGreaterThanOrEqual(9_500);
+    } finally {
+      proc.kill();
+      await proc.exited;
+    }
+  }, 60_000);
+
   test("a route build's registry check that has nothing to add reports no ssr status, so it cannot hide a failure", async () => {
     const { root } = track(await createTempApp("demo", path.join(import.meta.dir, "..", "local")));
     const appDir = path.join(root, "apps/demo");