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

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

@@ -4,6 +4,7 @@ import path from "node:path";
 export class CsrDevPaths {
   static readonly modulePrefix = "akan-module:";
   static readonly stubPrefix = "stub:";
+  static readonly emptyStubPrefix = "stub:empty:";
   static readonly vendorPrefix = "vendor:";
   readonly root: string;
 
@@ -43,16 +44,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 +74,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 +100,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 +112,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"));
+  });
 });