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

package/frontendBuild/clientEntryDiscovery.ts

@@ -1,3 +1,4 @@
+import fs from "node:fs";
 import path from "node:path";
 import { SOURCE_EXTS } from "../akanApp/devHostPolicy";
 import type { App } from "../commandDecorators";
@@ -17,6 +18,21 @@ interface FileFacts {
   imports: ScannedImport[];
 }
 
+interface Lookup<T> {
+  epoch: number;
+  promise: Promise<T>;
+  found?: boolean;
+}
+
+interface DiscoveryWalk {
+  visiting: Set<string>;
+  //? Walked below a file the walk was already inside (an import cycle): their result lacks what that file reaches.
+  partial: Set<string>;
+  //? Every file's result within this walk, partial ones included: the file the cycle went back to is an ancestor here
+  //? and brings the rest itself, and re-walking each path through a dense cycle grows exponentially.
+  memo: Map<string, Set<string>>;
+}
+
 const shouldSkipNodeModule = (absPath: string) => NODE_MODULES_RE.test(absPath) && !AKANJS_NODE_MODULE_RE.test(absPath);
 
 /** `"use client"` discovery over the import graph (dynamic imports included), flattening barrels as the bundler does. */
@@ -25,15 +41,13 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   #resolvePackage: PackageResolver;
   #analyzer: BarrelAnalyzer;
   #tsTranspiler = new Bun.Transpiler({ loader: "tsx" });
-  #fileExistsCache = new Map<string, Promise<boolean>>();
+  #fileExistsCache = new Map<string, Lookup<boolean>>();
   // Facts, never source text: this instance lives as long as the builder process, so texts would pin every file walked.
   #factsCache = new Map<string, Promise<FileFacts | null>>();
-  #resolvedFileCache = new Map<string, Promise<string | null>>();
-  #resolvedSpecifierCache = new Map<string, Promise<string | null>>();
+  #resolvedFileCache = new Map<string, Lookup<string | null>>();
+  #resolvedSpecifierCache = new Map<string, Lookup<string | null>>();
   #reachableEntriesCache = new Map<string, Set<string>>();
-  #missingFiles = new Set<string>();
-  #unresolvedPaths = new Set<string>();
-  #unresolvedSpecifiers = new Set<string>();
+  #readFiles = new Set<string>();
   //? Bumped by every invalidation: a walk that began before one computed from facts it may have read stale, so it
   //? answers its caller but caches nothing (a registry check walks this instance beside the slow lane's route builds).
   #epoch = 0;
@@ -51,48 +65,61 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   async discover(seeds: string[]): Promise<string[]> {
     const entries = new Set<string>();
     for (const seed of seeds) {
-      for (const entry of await this.#discoverFromFile(seed, new Set())) entries.add(entry);
+      const walk: DiscoveryWalk = { visiting: new Set(), partial: new Set(), memo: new Map() };
+      for (const entry of await this.#discoverFromFile(seed, walk)) entries.add(entry);
     }
     return Array.from(entries).sort();
   }
 
   invalidate(files: string[]): void {
+    if (files.length === 0) return;
+    let moved = false;
     for (const file of files) {
       const absPath = path.resolve(file);
+      const exists = fs.existsSync(absPath);
+      if (exists !== this.#readFiles.has(absPath)) moved = true;
+      if (!exists) this.#readFiles.delete(absPath);
       this.#factsCache.delete(absPath);
       this.#fileExistsCache.delete(absPath);
-      this.#reachableEntriesCache.delete(absPath);
     }
-    if (files.length === 0) return;
     this.#epoch += 1;
     // Reachable-entry results are transitive, so a changed child invalidates every ancestor.
     this.#reachableEntriesCache.clear();
-    this.#forgetMissing();
+    //? A file gone, or one never read, can leave a found resolution on its old target (`Chart.tsx` to
+    //? `Chart/index.tsx`), so a move drops them all; a save of a file already read keeps them (a walk re-resolving
+    //? every package cost 3x). Misses lapse with the epoch on their own (#lookup).
+    if (!moved) return;
+    this.#fileExistsCache.clear();
+    this.#resolvedFileCache.clear();
+    this.#resolvedSpecifierCache.clear();
   }
 
-  // Negatives are keyed by extension-less path or `dir\0specifier`, which a new file's path cannot reach, so all go.
-  #forgetMissing(): void {
-    for (const key of this.#missingFiles) this.#fileExistsCache.delete(key);
-    for (const key of this.#unresolvedPaths) this.#resolvedFileCache.delete(key);
-    for (const key of this.#unresolvedSpecifiers) this.#resolvedSpecifierCache.delete(key);
-    this.#missingFiles.clear();
-    this.#unresolvedPaths.clear();
-    this.#unresolvedSpecifiers.clear();
+  //? A found answer outlives later epochs; a miss, or a lookup still in flight, answers only walks of its own epoch, so
+  //? a file created meanwhile is looked up again.
+  #lookup<T>(cache: Map<string, Lookup<T>>, key: string, run: () => Promise<T>, isFound: (value: T) => boolean) {
+    const cached = cache.get(key);
+    if (cached && (cached.found || cached.epoch === this.#epoch)) return cached.promise;
+    const entry: Lookup<T> = { epoch: this.#epoch, promise: run() };
+    entry.promise.then(
+      (value) => {
+        entry.found = isFound(value);
+      },
+      () => {
+        entry.found = false;
+      },
+    );
+    cache.set(key, entry);
+    return entry.promise;
   }
 
   async #fileExists(p: string): Promise<boolean> {
     const absPath = path.resolve(p);
-    let cached = this.#fileExistsCache.get(absPath);
-    if (!cached) {
-      cached = Bun.file(absPath)
-        .exists()
-        .then((exists) => {
-          if (!exists) this.#missingFiles.add(absPath);
-          return exists;
-        });
-      this.#fileExistsCache.set(absPath, cached);
-    }
-    return cached;
+    return await this.#lookup(
+      this.#fileExistsCache,
+      absPath,
+      () => Bun.file(absPath).exists(),
+      (exists) => exists,
+    );
   }
 
   #facts(file: string): Promise<FileFacts | null> {
@@ -104,6 +131,7 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
           .text()
           .catch(() => null);
         if (content === null) return null;
+        this.#readFiles.add(absPath);
         if (USE_CLIENT_RE.test(content)) return { isClientEntry: true, imports: [] };
         return { isClientEntry: false, imports: this.#scanImports(await this.#rewrite(content)) };
       })();
@@ -131,58 +159,71 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
 
   async #resolveFileCandidate(absPathNoExt: string): Promise<string | null> {
     const cacheKey = path.resolve(absPathNoExt);
-    let cached = this.#resolvedFileCache.get(cacheKey);
-    if (cached) return cached;
-    cached = (async () => {
-      if (await this.#fileExists(cacheKey)) return cacheKey;
-      for (const ext of SOURCE_EXTS) {
-        const f = `${cacheKey}${ext}`;
-        if (await this.#fileExists(f)) return f;
-      }
-      for (const ext of SOURCE_EXTS) {
-        const f = path.join(cacheKey, `index${ext}`);
-        if (await this.#fileExists(f)) return f;
-      }
-      this.#unresolvedPaths.add(cacheKey);
-      return null;
-    })();
-    this.#resolvedFileCache.set(cacheKey, cached);
-    return cached;
+    return await this.#lookup(
+      this.#resolvedFileCache,
+      cacheKey,
+      async () => {
+        if (await this.#fileExists(cacheKey)) return cacheKey;
+        for (const ext of SOURCE_EXTS) {
+          const f = `${cacheKey}${ext}`;
+          if (await this.#fileExists(f)) return f;
+        }
+        for (const ext of SOURCE_EXTS) {
+          const f = path.join(cacheKey, `index${ext}`);
+          if (await this.#fileExists(f)) return f;
+        }
+        return null;
+      },
+      (file) => file !== null,
+    );
   }
 
   async #resolveSpecifier(spec: string, importerDir: string): Promise<string | null> {
     const cacheKey = `${importerDir}\0${spec}`;
-    let cached = this.#resolvedSpecifierCache.get(cacheKey);
-    if (cached) return cached;
-    cached = (async () => {
-      if (spec.startsWith(".") || spec.startsWith("/")) {
-        const abs = spec.startsWith("/") ? spec : path.resolve(importerDir, spec);
-        return this.#resolveFileCandidate(abs);
-      }
-      const pkg = await this.#resolvePackage(spec);
-      if (pkg) return pkg.entryFile;
-      this.#unresolvedSpecifiers.add(cacheKey);
-      return null;
-    })();
-    this.#resolvedSpecifierCache.set(cacheKey, cached);
-    return cached;
+    return await this.#lookup(
+      this.#resolvedSpecifierCache,
+      cacheKey,
+      async () => {
+        if (spec.startsWith(".") || spec.startsWith("/")) {
+          const abs = spec.startsWith("/") ? spec : path.resolve(importerDir, spec);
+          return await this.#resolveFileCandidate(abs);
+        }
+        const pkg = await this.#resolvePackage(spec);
+        return pkg ? pkg.entryFile : null;
+      },
+      (file) => file !== null,
+    );
   }
 
-  async #discoverFromFile(file: string, visiting: Set<string>): Promise<Set<string>> {
+  async #discoverFromFile(file: string, walk: DiscoveryWalk): Promise<Set<string>> {
     const epoch = this.#epoch;
     const absPath = path.resolve(file);
     const cached = this.#reachableEntriesCache.get(absPath);
     if (cached) return new Set(cached);
-    if (visiting.has(absPath) || shouldSkipNodeModule(absPath)) return new Set();
+    const memo = walk.memo.get(absPath);
+    if (memo) {
+      //? Reused from another path: whatever this path is walking now inherits its gap and stays out of the cache.
+      if (walk.partial.has(absPath)) for (const onPath of walk.visiting) walk.partial.add(onPath);
+      return new Set(memo);
+    }
+    if (walk.visiting.has(absPath)) {
+      let below = false;
+      for (const onPath of walk.visiting) {
+        if (below) walk.partial.add(onPath);
+        else below = onPath === absPath;
+      }
+      return new Set();
+    }
+    if (shouldSkipNodeModule(absPath)) return new Set();
 
-    visiting.add(absPath);
+    walk.visiting.add(absPath);
     const entries = new Set<string>();
     const facts = await this.#facts(absPath);
-    if (!facts) return this.#finishDiscovery(absPath, visiting, entries, epoch);
+    if (!facts) return this.#finishDiscovery(absPath, walk, entries, epoch);
 
     if (facts.isClientEntry) {
       entries.add(absPath);
-      return this.#finishDiscovery(absPath, visiting, entries, epoch);
+      return this.#finishDiscovery(absPath, walk, entries, epoch);
     }
 
     const importerDir = path.dirname(absPath);
@@ -193,15 +234,16 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
       const resolved = await this.#resolveSpecifier(spec, importerDir);
       if (!resolved) continue;
       if (shouldSkipNodeModule(resolved)) continue;
-      for (const entry of await this.#discoverFromFile(resolved, visiting)) entries.add(entry);
+      for (const entry of await this.#discoverFromFile(resolved, walk)) entries.add(entry);
     }
 
-    return this.#finishDiscovery(absPath, visiting, entries, epoch);
+    return this.#finishDiscovery(absPath, walk, entries, epoch);
   }
 
-  #finishDiscovery(absPath: string, visiting: Set<string>, entries: Set<string>, epoch: number): Set<string> {
-    visiting.delete(absPath);
-    if (epoch === this.#epoch) this.#reachableEntriesCache.set(absPath, entries);
+  #finishDiscovery(absPath: string, walk: DiscoveryWalk, entries: Set<string>, epoch: number): Set<string> {
+    walk.visiting.delete(absPath);
+    walk.memo.set(absPath, entries);
+    if (epoch === this.#epoch && !walk.partial.has(absPath)) this.#reachableEntriesCache.set(absPath, entries);
     return new Set(entries);
   }
 }

package/frontendBuild/csrDevModuleCompiler.test.ts

@@ -0,0 +1,89 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { App } from "../commandDecorators";
+import { CsrDevModuleCompiler } from "./csrDevModuleCompiler";
+import { CsrDevPaths } from "./csrDevPaths";
+import { CsrDevResolver } from "./csrDevResolver";
+import type { CsrDevContext } from "./csrDevTypes";
+
+const context: CsrDevContext = {
+  pageEntries: [],
+  basePaths: [],
+  htmlBasePaths: [],
+  define: {},
+  optimizeImports: [],
+  configKey: "key",
+  refreshFile: null,
+};
+
+//? esbuild's own interop helpers, as a pre-bundled chunk ships them (@mermaid-js/parser's dist/chunks).
+const prebundled = `var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+var parts = {};
+__reExport(parts, { a: 1 });
+var wrapped = __toESM({ b: 2 });
+export { parts, wrapped };
+`;
+
+describe("CsrDevModuleCompiler", () => {
+  let root: string;
+  const file = (relative: string) => path.join(root, relative);
+  const compile = async (relative: string) => {
+    const paths = new CsrDevPaths(root);
+    const compiler = new CsrDevModuleCompiler({
+      app: { verbose: () => undefined } as unknown as App,
+      paths,
+      resolver: new CsrDevResolver({ paths, context, entryFiles: [] }),
+      context,
+      outDir: file("out"),
+      routePrefix: "/_akan/registry/",
+    });
+    return await compiler.compile([file(relative)], new Set());
+  };
+
+  beforeAll(async () => {
+    root = CsrDevPaths.realpath(await mkdtemp(path.join(os.tmpdir(), "akan-csr-dev-compiler-")));
+    await Bun.write(file("node_modules/prebundled/chunk.mjs"), prebundled);
+    await Bun.write(file("node_modules/bare-reexport/index.mjs"), "export const parts = __reExport({}, { a: 1 });\n");
+    await Bun.write(file("node_modules/bare-toesm/index.mjs"), "export const wrapped = __toESM({ b: 2 });\n");
+  });
+
+  afterAll(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  test("a pre-bundled file keeps its own __reExport and __toESM, which Bun leaves in place of its own", async () => {
+    const { modules } = await compile("node_modules/prebundled/chunk.mjs");
+    const [module] = modules;
+    expect(module?.id).toBe("node_modules/prebundled/chunk.mjs");
+    const factory = module?.factory ?? "";
+    expect(factory).toContain("var __reExport = (target, mod, secondTarget) => (");
+    expect(factory).toContain("var __toESM = (mod, isNodeMode, target) => (");
+    expect(factory).not.toContain("__akan.reExport");
+    expect(factory).not.toContain("__akan.toESM");
+    expect(() => new Function(`return (${factory});`)).not.toThrow();
+  });
+
+  test.each([
+    ["__reExport", "node_modules/bare-reexport/index.mjs"],
+    ["__toESM", "node_modules/bare-toesm/index.mjs"],
+  ])("a %s call with no definition anywhere still stops the build", async (name, relative) => {
+    await expect(compile(relative)).rejects.toThrow(`Bun's ${name} helper no longer reads`);
+  });
+});

package/frontendBuild/csrDevModuleCompiler.ts

@@ -214,7 +214,7 @@ export class CsrDevModuleCompiler {
           const target = this.#resolver.resolve(
             importer,
             args.path,
-            args.kind === "require-call" ? "require" : "import",
+            args.kind === "require-call" || args.kind === "require-resolve" ? "require" : "import",
           );
           if (target === CsrDevResolver.inline) return undefined;
           if (target === null) {
@@ -262,11 +262,15 @@ export class CsrDevModuleCompiler {
   static #factory(id: string, code: string): { factory: string; helpers: CsrDevSharedHelpers | null } {
     const prefix = CsrDevPaths.modulePrefix;
     let patched = code.replaceAll(`import("${prefix}`, `__akanImport("${prefix}`).replace(/^\/\/# debugId=.*$/m, "");
+    //? A file esbuild already bundled (mermaid's parser chunks) defines its own helper under the same name, below Bun's
+    //? preamble, and Bun then emits none. Only a copy there is exempt: one in the preamble is Bun's own, changed.
+    const marker = patched.search(/^\/\/ /m);
+    const body = marker < 0 ? "" : patched.slice(marker);
     for (const [name, params, method] of CsrDevModuleCompiler.#helperPatches) {
       const definition = `var ${name} = ${params} => {`;
       if (patched.includes(definition))
         patched = patched.replace(definition, `var ${name} = __akan.${method}, __bun${name} = ${params} => {`);
-      else if (patched.includes(`${name}(`))
+      else if (patched.includes(`${name}(`) && !new RegExp(`\\b(?:var|let|const|function)\\s+${name}\\b`).test(body))
         throw new Error(
           `[csr-dev] ${id}: Bun's ${name} helper no longer reads "${definition}"; CsrDevModuleCompiler must follow`,
         );

package/frontendBuild/csrDevPatcher.test.ts

@@ -129,8 +129,10 @@ describe("CsrDevPatcher", () => {
     async writeEntries() {
       return { files: { "": this.#entry }, changed: [] };
     }
+    //? Roots beside the entries, as the SSR registry takes every client entry a route reaches.
+    extraRoots: string[] = [];
     protected async rootFiles(entryFiles: string[]) {
-      return entryFiles;
+      return [...entryFiles, ...this.extraRoots];
     }
     override async metadataFingerprint() {
       return "same";
@@ -143,12 +145,13 @@ describe("CsrDevPatcher", () => {
     }
   }
 
-  const movedRegistry = async (files: Record<string, string>) => {
+  const movedRegistry = async (files: Record<string, string>, { roots = [] }: { roots?: string[] } = {}) => {
     const root = await mkdtemp(path.join(os.tmpdir(), "akan-csr-dev-move-"));
     dirs.push(root);
     const file = (relative: string) => path.join(CsrDevPaths.realpath(root), "apps/demo", relative);
     for (const [relative, text] of Object.entries(files)) await Bun.write(file(relative), text);
     const bundler = new MovedRegistry(root, file("entry.ts"));
+    bundler.extraRoots = roots.map((relative) => file(relative));
     expect(await bundler.update([])).toMatchObject({ generation: 1, reload: true, first: true });
     const patcher = new CsrDevPatcher(bundler, { resident: true });
     expect(await patcher.update([])).toEqual({ kind: "unchanged" });
@@ -286,6 +289,235 @@ describe("CsrDevPatcher", () => {
     expect(changedIds(await patcher.update([file("ui/Card.tsx")]))).toEqual(["apps/demo/ui/Card.tsx"]);
   });
 
+  test("a broken module in the graph whose last importer drops it leaves the graph instead of failing every save", async () => {
+    const { bundler, patcher, file, changedIds } = await movedRegistry({
+      "ui/X.tsx": "export const x = 1;\n",
+      "ui/C.tsx": 'export const C = () => "c1";\n',
+      "ui/I.tsx": 'import { x } from "./X";\nexport const I = () => x;\n',
+      "entry.ts": 'import { C } from "./ui/C";\nimport { I } from "./ui/I";\nexport const run = [C, I];\n',
+    });
+    await Bun.write(file("ui/X.tsx"), "export const x = ;\n");
+    await expect(patcher.update([file("ui/X.tsx")])).rejects.toThrow();
+    await Bun.write(file("ui/I.tsx"), 'import { x } from "./X";\nexport const I = () => x + 1;\n');
+    await expect(patcher.update([file("ui/I.tsx")])).rejects.toThrow();
+
+    await Bun.write(file("ui/I.tsx"), "export const I = () => 0;\n");
+    expect(changedIds(await patcher.update([file("ui/I.tsx")]))).toEqual(["apps/demo/ui/I.tsx"]);
+    expect(((await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph).pending).toEqual([]);
+    await Bun.write(file("ui/C.tsx"), 'export const C = () => "c2";\n');
+    expect(changedIds(await patcher.update([file("ui/C.tsx")]))).toEqual(["apps/demo/ui/C.tsx"]);
+    const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+    expect(graph.modules["apps/demo/ui/X.tsx"]).toBeUndefined();
+    expect(graph.pending).toEqual([]);
+  });
+
+  test("a broken module left behind by a detached importer, or in a cycle, leaves with everything unreachable", async () => {
+    for (const shape of ["detached", "cycle"] as const) {
+      const { bundler, patcher, file, changedIds } = await movedRegistry({
+        "ui/X.tsx":
+          shape === "cycle" ? 'import { y } from "./Y";\nexport const x = () => y;\n' : "export const x = 1;\n",
+        "ui/Y.tsx": 'import { x } from "./X";\nexport const y = () => x;\n',
+        "ui/C.tsx": 'export const C = () => "c1";\n',
+        "ui/I.tsx": 'import { y } from "./Y";\nexport const I = () => y;\n',
+        "entry.ts": 'import { C } from "./ui/C";\nimport { I } from "./ui/I";\nexport const run = [C, I];\n',
+      });
+      await Bun.write(file("ui/X.tsx"), "export const x = ;\n");
+      await expect(patcher.update([file("ui/X.tsx")])).rejects.toThrow();
+      await Bun.write(file("ui/I.tsx"), "export const I = () => 0;\n");
+      expect(changedIds(await patcher.update([file("ui/I.tsx")]))).toEqual(["apps/demo/ui/I.tsx"]);
+      await Bun.write(file("ui/C.tsx"), 'export const C = () => "c2";\n');
+      expect(changedIds(await patcher.update([file("ui/C.tsx")]))).toEqual(["apps/demo/ui/C.tsx"]);
+      const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+      expect(Object.keys(graph.modules).sort()).toEqual([
+        "apps/demo/entry.ts",
+        "apps/demo/ui/C.tsx",
+        "apps/demo/ui/I.tsx",
+      ]);
+    }
+  });
+
+  test("a broken client entry no page names any more leaves the registry, though its last importer was a server file", async () => {
+    const { bundler, patcher, file, changedIds } = await movedRegistry(
+      {
+        "ui/X.tsx": 'export const X = () => "x";\n',
+        "ui/Y.tsx": 'export const Y = () => "y1";\n',
+        "entry.ts": "export {};\n",
+      },
+      { roots: ["ui/X.tsx", "ui/Y.tsx"] },
+    );
+    await Bun.write(file("ui/X.tsx"), "export const X = () => ;\n");
+    await expect(patcher.update([file("ui/X.tsx")])).rejects.toThrow();
+    bundler.extraRoots = [file("ui/Y.tsx")];
+    await Bun.write(file("page/P.tsx"), "export default () => null;\n");
+    expect(await patcher.update([file("page/P.tsx")])).toEqual({ kind: "unchanged" });
+    const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+    expect(graph.modules["apps/demo/ui/X.tsx"]).toBeUndefined();
+    expect(graph.pending).toEqual([]);
+    await Bun.write(file("ui/Y.tsx"), 'export const Y = () => "y2";\n');
+    expect(changedIds(await patcher.update([file("ui/Y.tsx")]))).toEqual(["apps/demo/ui/Y.tsx"]);
+  });
+
+  test("a require.resolve call weighs extensions as a require does", async () => {
+    const { bundler } = await movedRegistry({
+      "ui/pair/x.mjs": "export const x = 1;\n",
+      "ui/pair/x.js": "exports.x = 2;\n",
+      "ui/R.ts": 'export const where = require.resolve("./pair/x");\n',
+      "entry.ts": 'import { where } from "./ui/R";\nexport const run = where;\n',
+    });
+    const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+    expect(graph.resolution["apps/demo/ui/R.ts"]?.["./pair/x"]).toBe("apps/demo/ui/pair/x.js");
+  });
+
+  test("two routes' checks that both fail keep both roots pending", async () => {
+    const { bundler, patcher, file } = await movedRegistry({
+      "ui/Card.tsx": 'export const card = () => "v1";\n',
+      "ui/E1.tsx": 'import { gone } from "./missing1";\nexport const e1 = () => gone;\n',
+      "ui/E4.tsx": 'import { gone } from "./missing4";\nexport const e4 = () => gone;\n',
+      "entry.ts": 'import { card } from "./ui/Card";\nexport const run = card;\n',
+    });
+    bundler.wanted = new Set([file("ui/E1.tsx"), file("ui/E4.tsx")]);
+    await expect(patcher.update([], { roots: [file("ui/E1.tsx")], onlyRoots: true })).rejects.toThrow();
+    await expect(patcher.update([], { roots: [file("ui/E4.tsx")], onlyRoots: true })).rejects.toThrow();
+    const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+    expect(graph.pending.sort()).toEqual(["apps/demo/ui/E1.tsx", "apps/demo/ui/E4.tsx"]);
+  });
+
+  test("a route's check that adds its own root leaves another route's failed root pending", async () => {
+    const { bundler, patcher, file, changedIds } = await movedRegistry({
+      "ui/Card.tsx": 'export const card = () => "v1";\n',
+      "ui/E1.tsx": 'import { gone } from "./missingHelper";\nexport const e1 = () => gone;\n',
+      "ui/E3.tsx": "export const e3 = 3;\n",
+      "entry.ts": 'import { card } from "./ui/Card";\nexport const run = card;\n',
+    });
+    bundler.wanted = new Set([file("ui/E1.tsx"), file("ui/E3.tsx")]);
+    await expect(patcher.update([], { roots: [file("ui/E1.tsx")], onlyRoots: true })).rejects.toThrow();
+    await patcher.update([], { roots: [file("ui/E3.tsx")], onlyRoots: true });
+    const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+    expect(graph.pending).toEqual(["apps/demo/ui/E1.tsx"]);
+
+    await Bun.write(file("ui/E1.tsx"), "export const e1 = () => 1;\n");
+    expect(changedIds(await patcher.update([file("ui/E1.tsx")]))).toEqual(["apps/demo/ui/E1.tsx"]);
+  });
+
+  test("a pending root a worker failed on waits for an edit of its own or of a file its failure named", async () => {
+    const { bundler, patcher, file, changedIds } = await movedRegistry({
+      "ui/Card.tsx": 'export const card = () => "v1";\n',
+      "ui/Other.tsx": 'export const other = () => "o1";\n',
+      "ui/Broken.tsx": 'import { gone } from "./missingHelper";\nexport const broken = () => gone;\n',
+      "entry.ts":
+        'import { card } from "./ui/Card";\nimport { other } from "./ui/Other";\nexport const run = [card, other];\n',
+      "../../node_modules/fake-pkg/package.json": '{"name":"fake-pkg","main":"index.js"}',
+      "../../node_modules/fake-pkg/index.js": "export const gone = 1;\n",
+    });
+    bundler.wanted = new Set([file("ui/Broken.tsx")]);
+    await expect(patcher.update([], { roots: [file("ui/Broken.tsx")], onlyRoots: true })).rejects.toThrow();
+    const broken =
+      'import { gone } from "fake-pkg";\nimport { nope } from "./Card";\nexport const broken = () => gone + nope;\n';
+    await Bun.write(file("ui/Broken.tsx"), broken);
+    expect((await patcher.update([file("ui/Broken.tsx")])).kind).toBe("delegate");
+    //? The worker the builder runs next fails in Broken, naming Card: the resident patcher reads the graph it wrote.
+    await expect(bundler.update([file("ui/Broken.tsx")])).rejects.toThrow();
+    patcher.forget();
+
+    await Bun.write(file("ui/Other.tsx"), 'export const other = () => "o2";\n');
+    expect(changedIds(await patcher.update([file("ui/Other.tsx")]))).toEqual(["apps/demo/ui/Other.tsx"]);
+    expect(await patcher.update([], { roots: [file("ui/Broken.tsx")], onlyRoots: true })).toEqual({
+      kind: "unchanged",
+    });
+
+    await Bun.write(file("ui/Card.tsx"), 'export const card = () => "v2";\nexport const nope = 1;\n');
+    expect((await patcher.update([file("ui/Card.tsx")])).kind).toBe("delegate");
+    //? Its worker has not run yet: a route's check waits for it rather than handing the root over again.
+    expect(await patcher.update([], { roots: [file("ui/Broken.tsx")], onlyRoots: true })).toEqual({
+      kind: "unchanged",
+    });
+  });
+
+  test("a root handed to a worker that died before writing its failure is handed over again", async () => {
+    const { bundler, patcher, file } = await movedRegistry({
+      "ui/Card.tsx": 'export const card = () => "v1";\n',
+      "entry.ts": 'import { card } from "./ui/Card";\nexport const run = card;\n',
+      "../../node_modules/fake-pkg/package.json": '{"name":"fake-pkg","main":"index.js"}',
+      "../../node_modules/fake-pkg/index.js": "export const gone = 1;\n",
+    });
+    await Bun.write(file("ui/B.tsx"), 'import { gone } from "fake-pkg";\nexport const b = () => gone;\n');
+    bundler.wanted = new Set([file("ui/B.tsx")]);
+    const check = async () => await patcher.update([], { roots: [file("ui/B.tsx")], onlyRoots: true });
+    expect((await check()).kind).toBe("delegate");
+    expect(await check()).toEqual({ kind: "unchanged" });
+    //? What the builder does when that worker is killed (an OOM) before it writes anything.
+    patcher.releaseHandedOver();
+    patcher.forget();
+    expect((await check()).kind).toBe("delegate");
+  });
+
+  test("a pending root a worker failed on because of another file is tried again once that file is fixed", async () => {
+    const { bundler, patcher, file } = await movedRegistry({
+      "ui/Card.tsx": 'export const card = () => "v1";\n',
+      "ui/C.tsx": 'export const c = () => "c1";\n',
+      "entry.ts": 'import { card } from "./ui/Card";\nimport { c } from "./ui/C";\nexport const run = [card, c];\n',
+      "../../node_modules/fake-pkg/package.json": '{"name":"fake-pkg","main":"index.js"}',
+      "../../node_modules/fake-pkg/index.js": "export const gone = 1;\n",
+    });
+    await Bun.write(file("ui/B.tsx"), 'import { gone } from "fake-pkg";\nexport const b = () => gone;\n');
+    bundler.wanted = new Set([file("ui/B.tsx")]);
+    await Bun.write(file("ui/C.tsx"), "export const c = () => ;\n");
+    await expect(patcher.update([file("ui/C.tsx")])).rejects.toThrow();
+    expect((await patcher.update([], { roots: [file("ui/B.tsx")], onlyRoots: true })).kind).toBe("delegate");
+    await expect(bundler.update([], { roots: [file("ui/B.tsx")] })).rejects.toThrow();
+    patcher.forget();
+
+    await Bun.write(file("ui/C.tsx"), 'export const c = () => "c2";\n');
+    expect((await patcher.update([file("ui/C.tsx")])).kind).toBe("delegate");
+  });
+
+  test.skipIf(!foldsCase)(
+    "an importer still naming the old spelling compiles with the new one, so app.js defines what it requires",
+    async () => {
+      const { patcher, file, app, changedIds } = await movedRegistry({
+        "ui/card.tsx": 'export const card = () => "v1";\n',
+        "ui/Page.tsx": 'import { card } from "./card";\nexport const page = () => card();\n',
+        "entry.ts": 'import { page } from "./ui/Page";\nexport const run = page;\n',
+      });
+      fs.renameSync(file("ui/card.tsx"), file("ui/Card.tsx"));
+      await Bun.write(file("ui/Card.tsx"), 'export const card = () => "v2";\n');
+      expect(changedIds(await patcher.update([file("ui/Card.tsx")]))).toEqual([
+        "apps/demo/ui/Card.tsx",
+        "apps/demo/ui/Page.tsx",
+      ]);
+      expect(await app()).toContain('__akan.define("apps/demo/ui/Card.tsx"');
+      expect(await app()).not.toContain('__akan.define("apps/demo/ui/card.tsx"');
+      await Bun.write(file("ui/Other.tsx"), "export const other = 1;\n");
+      expect(await patcher.update([file("ui/Other.tsx")])).toEqual({ kind: "unchanged" });
+    },
+  );
+
+  test.skipIf(!foldsCase)(
+    "a case-only rename the patcher never saw moves the module once, and later saves leave it alone",
+    async () => {
+      for (const resident of [false, true]) {
+        const { bundler, patcher, file, changedIds } = await movedRegistry({
+          "ui/card.tsx": 'export const card = () => "v1";\n',
+          "ui/Page.tsx": 'import { card } from "./card";\nexport const page = () => card();\n',
+          "entry.ts": 'import { page } from "./ui/Page";\nexport const run = page;\n',
+        });
+        fs.renameSync(file("ui/card.tsx"), file("ui/Card.tsx"));
+        await Bun.write(file("ui/Page.tsx"), 'import { card } from "./Card";\nexport const page = () => card();\n');
+        const later = resident ? patcher : new CsrDevPatcher(bundler, { resident: true });
+        expect(changedIds(await later.update([file("ui/Page.tsx")]))).toEqual([
+          "apps/demo/ui/Card.tsx",
+          "apps/demo/ui/Page.tsx",
+        ]);
+        await Bun.write(file("ui/Card.tsx"), 'export const card = () => "v2";\n');
+        expect(changedIds(await later.update([file("ui/Card.tsx")]))).toEqual(["apps/demo/ui/Card.tsx"]);
+        await Bun.write(file("ui/Other.tsx"), "export const other = 1;\n");
+        expect(await later.update([file("ui/Other.tsx")])).toEqual({ kind: "unchanged" });
+        const graph = (await bundler.writer.readJson<CsrDevGraph>("graph.json")) as CsrDevGraph;
+        expect(graph.modules["apps/demo/ui/card.tsx"]).toBeUndefined();
+      }
+    },
+  );
+
   test("by default a pending root counts as reached only while an entry or a module imports it", async () => {
     const { bundler, patcher, file, changedIds } = await movedRegistry({
       "ui/Card.tsx": 'export const card = () => "v1";\n',