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

package/frontendBuild/csrDevPatcher.ts

@@ -35,6 +35,9 @@ export class CsrDevPatcher {
   readonly #bundler: DevRegistryBundler;
   readonly #resident: boolean;
   #state: CsrDevPatcherState | null = null;
+  //? A pending root handed to a worker, by the hash it had: one that fails there too waits for an edit of its own or of
+  //? a file the worker failed in, instead of sending every save to a worker.
+  readonly #delegated = new Map<string, { hash: string; failed?: Record<string, string>; before: string }>();
 
   constructor(bundler: DevRegistryBundler, { resident = false }: { resident?: boolean } = {}) {
     this.#bundler = bundler;
@@ -46,6 +49,11 @@ export class CsrDevPatcher {
     this.#state = null;
   }
 
+  /** Roots handed to a worker that died before it wrote their failure: the next round hands them over again. */
+  releaseHandedOver(): void {
+    for (const [id, handedOver] of this.#delegated) if (!handedOver.failed) this.#delegated.delete(id);
+  }
+
   async update(
     changedFiles: string[] = [],
     { announce, roots = [], onlyRoots = false, allowWholeAppBuilds = false }: CsrDevPatchOptions = {},
@@ -104,7 +112,10 @@ export class CsrDevPatcher {
     for (const id of this.#withoutFactory(state, present)) changed.add(id);
     for (const file of entries.changed) changed.add(paths.idOf(file));
     const rootFiles = [...Object.values(entries.files), ...roots.filter((file) => fs.existsSync(file))];
-    for (const file of rootFiles) if (!graph.modules[paths.idOf(file)]) changed.add(paths.idOf(file));
+    for (const file of rootFiles) {
+      const id = paths.idOf(file);
+      if (!graph.modules[id] && !(onlyRoots && (await this.#parked(graph, id)))) changed.add(id);
+    }
     const carried = onlyRoots ? [] : await this.#carriedRoots(graph, changed, present);
     const routesMoved =
       this.#bundler.reloadsOnEntryChange &&
@@ -124,15 +135,26 @@ export class CsrDevPatcher {
       runtimeResolved: graph.runtimeResolved,
     });
     const known = new Set(Object.keys(graph.modules).map((id) => paths.fileOf(id)));
-    let result: CsrDevCompileResult;
-    try {
-      result = await this.#bundler.compiler(context, resolver).compile(
-        [...changed].map((id) => paths.fileOf(id)),
+    const compile = async (ids: string[]) =>
+      await this.#bundler.compiler(context, resolver).compile(
+        ids.map((id) => paths.fileOf(id)),
         known,
         { refuseNewVendor: !allowWholeAppBuilds, refusePrepass: !allowWholeAppBuilds },
       );
+    let result: CsrDevCompileResult;
+    let orphans: string[];
+    try {
+      ({ result, orphans } = await this.#compileLeavingOrphans(compile, graph, changed));
+      for (const module of result.modules) known.add(module.file);
+      result = await this.#withTwinImporters(compile, graph, result);
     } catch (error) {
-      graph.pending = [...new Set([...changed, ...carried])];
+      //? Joined, not replaced: a route's root another round failed stays pending for its own retry.
+      graph.pending = [...new Set([...graph.pending, ...changed, ...carried])];
+      if (!this.#resident)
+        graph.failed = {
+          roots: [...changed, ...carried],
+          files: await CsrDevPatcher.#hashesOf(paths, CsrDevPatcher.#implicatedFiles(error)),
+        };
       await writer.writeJson("graph.json", graph);
       throw error;
     }
@@ -146,13 +168,29 @@ export class CsrDevPatcher {
       //? The entry files are already rewritten, so the worker would see them unchanged and patch a moved route table:
       //? a graph whose entries name none makes it reload instead.
       if (routesMoved) await writer.writeJson("graph.json", { ...graph, entries: {} });
+      if (onlyRoots)
+        for (const id of changed)
+          if (!graph.modules[id])
+            this.#delegated.set(id, {
+              hash: await CsrDevPaths.hashOf(paths.fileOf(id)),
+              before: JSON.stringify(graph.failed ?? null),
+            });
       return this.#handBack(refusal, generation, context);
     }
     const compiled = result.modules;
     const vendorJoined = compiled.some((module) => module.vendor && !graph.modules[module.id]);
     //? Read before the merge: a new module's file is written after announcing, and one without a file is compiled now.
     const code = await this.#code(state);
+    for (const id of [...orphans, ...this.#caseTwins(graph, compiled)]) {
+      delete graph.modules[id];
+      resolver.forget(paths.fileOf(id));
+      code?.modules.delete(id);
+      forgotten.push(id);
+    }
+    graph.pending = graph.pending.filter((id) => !orphans.includes(id));
     this.#bundler.merge(graph, resolver, compiled);
+    if (!this.#resident) delete graph.failed;
+    for (const module of compiled) this.#delegated.delete(module.id);
     graph.entries = entryIds;
     for (const module of compiled) {
       if (module.vendor || !code) continue;
@@ -169,6 +207,13 @@ export class CsrDevPatcher {
         : constantId
           ? `${path.basename(constantId)} changed`
           : undefined;
+    //? Only orphans left the graph: nothing a tab holds changed, so no patch goes out.
+    if (compiled.length === 0 && !reason) {
+      await writer.writeJson("graph.json", graph);
+      await writer.forgetModules(forgotten);
+      if (carried.length === 0) return { kind: "unchanged" };
+      return await this.#retryCarried(context, state, carried, { announce, allowWholeAppBuilds });
+    }
     const previous = state.manifest;
     const next: CsrDevManifest = { ...previous, generation, entries: entryIds };
     const update = (patchUrl?: string): CsrDevUpdate => ({
@@ -241,6 +286,108 @@ export class CsrDevPatcher {
     return retried;
   }
 
+  //? One Bun.build fails whole: a module that fails to compile and that nothing reaches any more (its last importer
+  //? dropped the import in this very save) leaves the graph, where it would fail every later save until fixed itself.
+  //? Everything else the roots stopped reaching goes with it, or an importer left behind would bring it back.
+  async #compileLeavingOrphans(
+    compile: (ids: string[]) => Promise<CsrDevCompileResult>,
+    graph: CsrDevGraph,
+    changed: Set<string>,
+  ): Promise<{ result: CsrDevCompileResult; orphans: string[] }> {
+    const { paths } = this.#bundler;
+    try {
+      return { result: await compile([...changed]), orphans: [] };
+    } catch (error) {
+      const failing = new Set(CsrDevPatcher.#failingFiles(error).map((file) => paths.idOf(file)));
+      const broken = [...changed].filter((id) => failing.has(id) && graph.modules[id]);
+      if (broken.length === 0) throw error;
+      const rest = [...changed].filter((id) => !broken.includes(id));
+      const empty: CsrDevCompileResult = { modules: [], refusedVendors: [], unresolved: [] };
+      const result =
+        rest.length === 0
+          ? empty
+          : await compile(rest).catch(() => {
+              throw error;
+            });
+      const modules = { ...graph.modules };
+      for (const module of result.modules)
+        modules[module.id] = {
+          vendor: module.vendor,
+          mtimeMs: module.mtimeMs,
+          hash: module.hash,
+          deps: module.deps.map((dep) => (CsrDevPaths.isStub(dep) ? dep : paths.idOf(dep))),
+        };
+      const reached = await this.#bundler.reachable({ ...graph, modules });
+      if (broken.some((id) => reached.has(id))) throw error;
+      const orphans = Object.keys(modules).filter((id) => !reached.has(id) && !modules[id]?.vendor);
+      return { result, orphans };
+    }
+  }
+
+  //? A case-only rename the patcher never saw (made while CSR was unarmed) compiles under the disk's spelling: the old
+  //? id goes, or its stale mtime would compile it again on every save. Only where the disk folds case: on ext4 the two
+  //? spellings are two files.
+  #caseTwins(graph: CsrDevGraph, compiled: CsrDevCompileResult["modules"]): string[] {
+    const { paths } = this.#bundler;
+    const idsByFold = new Map<string, string[]>();
+    for (const id of Object.keys(graph.modules))
+      idsByFold.set(id.toLowerCase(), [...(idsByFold.get(id.toLowerCase()) ?? []), id]);
+    return compiled.flatMap((module) =>
+      (idsByFold.get(module.id.toLowerCase()) ?? []).filter(
+        (id) => id !== module.id && !graph.modules[id]?.vendor && !CsrDevPaths.isNamed(paths.fileOf(id)),
+      ),
+    );
+  }
+
+  //? Their importers compile in the same round: one still importing the old spelling (valid on a disk that folds case)
+  //? would otherwise require a module app.js no longer defines.
+  async #withTwinImporters(
+    compile: (ids: string[]) => Promise<CsrDevCompileResult>,
+    graph: CsrDevGraph,
+    result: CsrDevCompileResult,
+  ): Promise<CsrDevCompileResult> {
+    const twins = new Set(this.#caseTwins(graph, result.modules));
+    if (twins.size === 0) return result;
+    const compiledIds = new Set(result.modules.map((module) => module.id));
+    const importers = Object.entries(graph.modules)
+      .filter(([id, module]) => !module.vendor && !compiledIds.has(id) && !twins.has(id))
+      .filter(([, module]) => module.deps.some((dep) => twins.has(dep)))
+      .map(([id]) => id);
+    if (importers.length === 0) return result;
+    const more = await compile(importers);
+    return {
+      modules: [...result.modules, ...more.modules],
+      refusedVendors: [...result.refusedVendors, ...more.refusedVendors],
+      unresolved: [...result.unresolved, ...more.unresolved],
+    };
+  }
+
+  //? Where it failed, and the files its messages name: Bun puts a missing export at the importer and names the module
+  //? that lacks it only in the text ("No matching export in \"../ui/C.tsx\""), relative to the working directory.
+  static #implicatedFiles(error: unknown): string[] {
+    const failing = CsrDevPatcher.#failingFiles(error);
+    const messages: unknown[] = error instanceof AggregateError ? error.errors : [];
+    const named = messages.flatMap((message) => {
+      const text = String((message as { message?: unknown }).message ?? "");
+      const bases = [process.cwd(), ...failing.map((file) => path.dirname(file))];
+      return [...text.matchAll(/"([^"\n]+)"/g)].flatMap(([, quoted = ""]) => {
+        const found = bases
+          .map((base) => path.resolve(base, quoted))
+          .find((file) => CsrDevPaths.isScript(file) && fs.existsSync(file));
+        return found ? [CsrDevPaths.realpath(found)] : [];
+      });
+    });
+    return [...new Set([...failing, ...named])];
+  }
+
+  static #failingFiles(error: unknown): string[] {
+    const messages: unknown[] = error instanceof AggregateError ? error.errors : [];
+    return messages
+      .map((message) => (message as { position?: { file?: unknown } | null }).position?.file)
+      .filter((file): file is string => typeof file === "string" && path.isAbsolute(file))
+      .map((file) => CsrDevPaths.realpath(file));
+  }
+
   //? A pending root outside the graph (a route's entry that failed to compile) is retried while a route still reaches
   //? it; one no route names any more (the page stopped importing it) leaves the pending list instead.
   async #carriedRoots(graph: CsrDevGraph, changed: Set<string>, present: (file: string) => boolean): Promise<string[]> {
@@ -251,11 +398,35 @@ export class CsrDevPatcher {
       outside.map((id) => paths.fileOf(id)),
       graph,
     );
-    const carried = outside.filter((id) => wanted.has(paths.fileOf(id)));
-    graph.pending = graph.pending.filter((id) => graph.modules[id] || carried.includes(id));
+    const kept = outside.filter((id) => wanted.has(paths.fileOf(id)));
+    graph.pending = graph.pending.filter((id) => graph.modules[id] || kept.includes(id));
+    const carried: string[] = [];
+    for (const id of kept) if (!(await this.#parked(graph, id))) carried.push(id);
     return carried;
   }
 
+  //? The worker's failure is read from the graph it wrote, once, and only a round that built this root. Until that
+  //? worker writes, the record on disk is the one from before the hand-over, and the root waits for it.
+  async #parked(graph: CsrDevGraph, id: string): Promise<boolean> {
+    const { paths } = this.#bundler;
+    const handedOver = this.#delegated.get(id);
+    if (!handedOver || handedOver.hash !== (await CsrDevPaths.hashOf(paths.fileOf(id)))) return false;
+    if (!handedOver.failed) {
+      if (JSON.stringify(graph.failed ?? null) === handedOver.before) return true;
+      if (graph.failed?.roots.includes(id)) handedOver.failed = graph.failed.files;
+    }
+    if (!handedOver.failed) return false;
+    for (const [failedId, hash] of Object.entries(handedOver.failed))
+      if ((await CsrDevPaths.hashOf(paths.fileOf(failedId))) !== hash) return false;
+    return true;
+  }
+
+  static async #hashesOf(paths: CsrDevPaths, files: string[]): Promise<Record<string, string>> {
+    return Object.fromEntries(
+      await Promise.all(files.map(async (file) => [paths.idOf(file), await CsrDevPaths.hashOf(file)] as const)),
+    );
+  }
+
   // Missing factory files are recompiled, not read: a registry whose graph outlived them would fail every read. The
   // resident patcher holds every factory it has read or written, so only a registry just read from disk is stat'ed.
   #withoutFactory({ graph, code }: CsrDevPatcherState, present: (file: string) => boolean): string[] {
@@ -268,7 +439,8 @@ export class CsrDevPatcher {
 
   //? A case-only rename is the one move `existsSync` misses (`ui/card.tsx` still exists after a rename to
   //? `ui/Card.tsx` on APFS and NTFS), and it reaches the patcher as a save of both names: the realpath of every
-  //? module is paid for only then (2.2ms a save on a 385-module registry, against 0.3ms).
+  //? module is paid for only then (2.2ms a save on a 385-module registry, against 0.3ms). One it never saw goes with
+  //? the compile that meets the new spelling (#caseTwins).
   static #presence(changedFiles: string[]): (file: string) => boolean {
     const caseMoved = changedFiles.some((file) => fs.existsSync(file) && !CsrDevPaths.isNamed(file));
     return caseMoved ? (file) => CsrDevPaths.isNamed(file) : (file) => fs.existsSync(file);
@@ -327,7 +499,9 @@ export class CsrDevPatcher {
       if (changed.has(id)) continue;
       for (const dep of module.deps) {
         if (graph.modules[dep] || CsrDevPaths.isStub(dep)) continue;
-        if (present(paths.fileOf(dep))) changed.add(dep);
+        //? Named, not only present: a dep a case rename replaced still exists under its old spelling.
+        const file = paths.fileOf(dep);
+        if (present(file) && CsrDevPaths.isNamed(file)) changed.add(dep);
         else if (!module.vendor) changed.add(id);
       }
     }

package/frontendBuild/csrDevPaths.ts

@@ -43,16 +43,18 @@ export class CsrDevPaths {
     return (await source.exists()) ? Bun.hash(await source.arrayBuffer()).toString(36) : "";
   }
 
+  //? `.native`: on Windows Bun's `fs.realpathSync` keeps the spelling it was given, where the native call returns the
+  //? disk's (as macOS's plain call does), and a module id must not depend on which spelling reached it first.
   static realpath(file: string): string {
     // A deleted file keeps its own path, so its id still matches the graph entry it leaves behind.
-    return fs.existsSync(file) ? fs.realpathSync(file) : path.resolve(file);
+    return fs.existsSync(file) ? fs.realpathSync.native(file) : path.resolve(file);
   }
 
   //? Present under this very name: on a case-insensitive disk (APFS, NTFS) `ui/card.tsx` still exists after a rename to
   //? `ui/Card.tsx`, but the compiler names the module by the disk's spelling, so the old id is gone.
   static isNamed(file: string): boolean {
     try {
-      return fs.realpathSync(file) === file;
+      return fs.realpathSync.native(file) === file;
     } catch {
       // Missing is an answer here.
       return false;
@@ -71,15 +73,22 @@ export class CsrDevPaths {
     return CsrDevPaths.#asFile(base, kind) ?? CsrDevPaths.#asFolder(base, kind);
   }
 
+  //? A specifier ending in `/`, `.` or `..` names the folder alone, for Bun too: `./Foo/` never takes a `Foo.tsx`.
+  static resolveRelative(dir: string, specifier: string, kind: "import" | "require" = "import"): string | null {
+    const base = path.resolve(dir, specifier);
+    const folder = /(^|[\\/])\.\.?$|[\\/]$/.test(specifier);
+    return folder ? CsrDevPaths.#asFolder(base, kind) : CsrDevPaths.resolveOnDisk(base, kind);
+  }
+
   static #asFile(base: string, kind: "import" | "require"): string | null {
     const isFile = (candidate: string) => fs.statSync(candidate, { throwIfNoEntry: false })?.isFile() ?? false;
     return [base, ...CsrDevPaths.#extensions[kind].map((extension) => `${base}${extension}`)].find(isFile) ?? null;
   }
 
-  //? A folder's package.json names its entry as a browser build reads it: `browser` (the string form), then `module`,
-  //? then `main`, which may itself name a folder; without one, its `index`.
+  //? A folder's package.json names its entry as a browser build reads it: `browser` (the string form), then `module`
+  //? (an import only), then `main`, which may itself name a folder; without one, its `index`.
   static #asFolder(dir: string, kind: "import" | "require"): string | null {
-    const entry = CsrDevPaths.#packageEntryOf(dir);
+    const entry = CsrDevPaths.#packageEntryOf(dir, kind);
     const named = entry
       ? (CsrDevPaths.#asFile(path.join(dir, entry), kind) ?? CsrDevPaths.#indexOf(path.join(dir, entry), kind))
       : null;
@@ -90,10 +99,11 @@ export class CsrDevPaths {
     return CsrDevPaths.#asFile(path.join(dir, "index"), kind);
   }
 
-  static #packageEntryOf(dir: string): string | null {
+  static #packageEntryOf(dir: string, kind: "import" | "require"): string | null {
     try {
       const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8")) as Record<string, unknown>;
-      const entry = [pkg.browser, pkg.module, pkg.main].find((field) => typeof field === "string");
+      const fields = kind === "require" ? [pkg.browser, pkg.main] : [pkg.browser, pkg.module, pkg.main];
+      const entry = fields.find((field) => typeof field === "string");
       return typeof entry === "string" ? entry : null;
     } catch {
       // No package.json, or one that names no entry: the folder's index answers.
@@ -101,10 +111,20 @@ export class CsrDevPaths {
     }
   }
 
-  /** True when `known`, a file inside the folder `base` names, would lose to a file `base` names directly. */
-  static isShadowed(base: string, known: string): boolean {
-    const dir = CsrDevPaths.realpath(base);
-    return known.startsWith(`${dir}${path.sep}`) && CsrDevPaths.#asFile(base, "import") !== null;
+  //? The package folder's ctime: Bun installs by cloning (macOS) or hard-linking (Linux) its cache, so a file keeps the
+  //? cache's mtime, and a hard link's ctime moves whenever another project links the same version; the folder is made
+  //? by this project's install alone.
+  /** A bare specifier whose package landed in a `node_modules` at or above `from` after `since`. */
+  static installedSince(specifier: string, from: string, since: number): boolean {
+    const [first = "", second = ""] = specifier.split("/");
+    const name = first.startsWith("@") ? `${first}/${second}` : first;
+    if (!name || name.startsWith(".")) return false;
+    for (let dir = path.resolve(from); ; dir = path.dirname(dir)) {
+      const pkgDir = path.join(dir, "node_modules", name);
+      if (fs.existsSync(path.join(pkgDir, "package.json")))
+        return (fs.statSync(pkgDir, { throwIfNoEntry: false })?.ctimeMs ?? 0) > since;
+      if (path.dirname(dir) === dir) return false;
+    }
   }
 
   static tryResolve(specifier: string, from: string): string | null {

package/frontendBuild/csrDevResolver.test.ts

@@ -126,10 +126,29 @@ describe("CsrDevPaths.resolveOnDisk", () => {
       "dirmain/index.js",
       "shadow/Foo/index.tsx",
       "shadow/Page.tsx",
+      "sibling/x.ts",
+      "sibling/Page.tsx",
+      "slash/Foo/index.ts",
+      "slash/Foo.ts",
+      "slash/Page.tsx",
+      "req/index.js",
+      "req/main.js",
+      "req/m.js",
+      "modonly/index.js",
+      "modonly/m.js",
+      "dot/Foo.tsx",
+      "dot/Foo/index.tsx",
+      "dot/Foo/Sub/x.ts",
+      "bmap/lib/server.ts",
+      "bmap/lib/client.ts",
+      "bmap/entry.ts",
     ])
       await Bun.write(at(relative), "export {};\n");
     await Bun.write(at("fields/package.json"), '{ "browser": "b.js", "module": "m.js", "main": "main.js" }');
     await Bun.write(at("dirmain/package.json"), '{ "main": "lib" }');
+    await Bun.write(at("req/package.json"), '{ "module": "m.js", "main": "main.js" }');
+    await Bun.write(at("modonly/package.json"), '{ "module": "m.js" }');
+    await Bun.write(at("bmap/package.json"), '{ "browser": { "./lib/server.ts": "./lib/client.ts" } }');
   });
 
   afterAll(async () => {
@@ -146,7 +165,49 @@ describe("CsrDevPaths.resolveOnDisk", () => {
     expect(CsrDevPaths.resolveOnDisk(at("dirmain"))).toBe(at("dirmain/lib/index.js"));
   });
 
-  test("a recorded resolution is overturned only by a file created beside the folder it went into", async () => {
+  test("a require call reads no module field: main when there is one, otherwise the index", () => {
+    expect(CsrDevPaths.resolveOnDisk(at("req"))).toBe(at("req/m.js"));
+    expect(CsrDevPaths.resolveOnDisk(at("req"), "require")).toBe(at("req/main.js"));
+    expect(CsrDevPaths.resolveOnDisk(at("modonly"), "require")).toBe(at("modonly/index.js"));
+  });
+
+  test("a bare import Bun cannot resolve here goes to a worker only when its package landed after this process began", async () => {
+    //? A package Bun's resolver misses in this process: it keeps node_modules listings, so one added by `bun add` while
+    //? the builder runs looks like this until a fresh process reads it.
+    await Bun.write(at("inst/node_modules/half/package.json"), '{ "name": "half", "main": "missing.js" }');
+    await Bun.write(at("inst/src/a.ts"), 'import "half";\n');
+    const started = (startedAt: number) =>
+      new CsrDevResolver({ paths: new CsrDevPaths(root), context, entryFiles: [], startedAt });
+    const before = started(Date.now() - 60_000);
+    expect(before.resolve(at("inst/src/a.ts"), "half")).toBeNull();
+    expect(before.resolve(at("inst/src/a.ts"), "half/formatt")).toBeNull();
+    expect(() => before.resolve(at("inst/src/a.ts"), "nowhere-to-be-found")).toThrow("cannot resolve");
+    //? Installed before the builder started: its listing is Bun's, so a miss is a typo or a half-typed import.
+    const after = started(Date.now() + 60_000);
+    expect(() => after.resolve(at("inst/src/a.ts"), "half/formatt")).toThrow("cannot resolve");
+  });
+
+  test('"." and ".." name the folder alone, as a trailing slash does', () => {
+    expect(CsrDevPaths.resolveRelative(at("dot/Foo"), ".")).toBe(at("dot/Foo/index.tsx"));
+    expect(CsrDevPaths.resolveRelative(at("dot/Foo/Sub"), "..")).toBe(at("dot/Foo/index.tsx"));
+  });
+
+  test("app code under a package.json that maps files with a browser object keeps the recorded answer", () => {
+    const resolver = new CsrDevResolver({
+      paths: new CsrDevPaths(root),
+      context,
+      entryFiles: [],
+      resolution: { "bmap/entry.ts": { "./lib/server": "bmap/lib/client.ts" } },
+    });
+    expect(resolver.resolve(at("bmap/entry.ts"), "./lib/server")).toBe(at("bmap/lib/client.ts"));
+  });
+
+  test("a specifier ending in a slash names the folder alone", () => {
+    expect(CsrDevPaths.resolveRelative(at("slash"), "./Foo/")).toBe(at("slash/Foo/index.ts"));
+    expect(CsrDevPaths.resolveRelative(at("slash"), "./Foo")).toBe(at("slash/Foo.ts"));
+  });
+
+  test("a recorded relative resolution stands while the disk resolves it the same way", async () => {
     const paths = new CsrDevPaths(root);
     const resolver = new CsrDevResolver({
       paths,
@@ -157,9 +218,22 @@ describe("CsrDevPaths.resolveOnDisk", () => {
         "pair/entry.ts": { "./x": "pair/x.js" },
       },
     });
-    expect(resolver.resolve(at("pair/entry.ts"), "./x")).toBe(at("pair/x.js"));
+    expect(resolver.resolve(at("pair/entry.ts"), "./x", "require")).toBe(at("pair/x.js"));
+    expect(resolver.resolve(at("pair/entry.ts"), "./x")).toBe(at("pair/x.mjs"));
     expect(resolver.resolve(at("shadow/Page.tsx"), "./Foo")).toBe(at("shadow/Foo/index.tsx"));
     await Bun.write(at("shadow/Foo.tsx"), "export {};\n");
     expect(resolver.resolve(at("shadow/Page.tsx"), "./Foo")).toBe(at("shadow/Foo.tsx"));
   });
+
+  test("a sibling with a stronger extension takes over a recorded import", async () => {
+    const resolver = new CsrDevResolver({
+      paths: new CsrDevPaths(root),
+      context,
+      entryFiles: [],
+      resolution: { "sibling/Page.tsx": { "./x": "sibling/x.ts" } },
+    });
+    expect(resolver.resolve(at("sibling/Page.tsx"), "./x")).toBe(at("sibling/x.ts"));
+    await Bun.write(at("sibling/x.tsx"), "export {};\n");
+    expect(resolver.resolve(at("sibling/Page.tsx"), "./x")).toBe(at("sibling/x.tsx"));
+  });
 });

package/frontendBuild/csrDevResolver.ts

@@ -22,6 +22,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 +36,20 @@ 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, boolean>();
+  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))
@@ -95,7 +107,7 @@ export class CsrDevResolver {
   resolve(importer: string, specifier: string, kind: "import" | "require" = "import"): string | null {
     if (this.#isInlineSpecifier(specifier)) return CsrDevResolver.inline;
     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 +115,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 +139,31 @@ export class CsrDevResolver {
     });
   }
 
+  #hasBrowserMap(dir: string): boolean {
+    const cached = this.#browserMaps.get(dir);
+    if (cached !== undefined) return cached;
+    const pkgFile = path.join(dir, "package.json");
+    const parent = path.dirname(dir);
+    let mapped: boolean;
+    if (fs.existsSync(pkgFile)) {
+      try {
+        const browser = (JSON.parse(fs.readFileSync(pkgFile, "utf8")) as { browser?: unknown }).browser;
+        mapped = typeof browser === "object" && browser !== null;
+      } catch {
+        // An unreadable package.json maps nothing; Bun's build fails on it anyway.
+        mapped = false;
+      }
+    } else mapped = parent !== dir && this.#hasBrowserMap(parent);
+    this.#browserMaps.set(dir, mapped);
+    return mapped;
+  }
+
+  /** 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 +195,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 +206,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();
   }