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

package/frontendBuild/csrDevModuleCompiler.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import type { BunPlugin } from "bun";
 import type { App } from "../commandDecorators";
+import { CsrDevFactoryCheck } from "./csrDevFactoryCheck";
 import { CsrDevPaths } from "./csrDevPaths";
 import { CsrDevResolver } from "./csrDevResolver";
 import type { CsrDevCompiledModule, CsrDevContext, CsrDevSharedHelpers } from "./csrDevTypes";
@@ -82,6 +83,7 @@ export class CsrDevModuleCompiler {
     while (frontier.length > 0) {
       const refusedVendors = refuseNewVendor ? frontier.filter((file) => CsrDevPaths.isVendorFile(file)) : [];
       if (refusedVendors.length > 0) return { modules: [...compiled.values()], refusedVendors, unresolved: [] };
+      await this.#resolver.cover(frontier);
       const round = await this.#compileRound(frontier);
       if (round.misses.length > 0 && !this.#resolver.prepassDone && refusePrepass)
         return { modules: [...compiled.values()], refusedVendors: [], unresolved: round.misses };
@@ -138,21 +140,29 @@ export class CsrDevModuleCompiler {
       ),
     );
     const misses: string[] = [];
-    const result = await Bun.build({
-      entrypoints: files,
-      root: this.#paths.root,
-      target: "browser",
-      format: "cjs",
-      reactFastRefresh: !vendor,
-      sourcemap: vendor ? "none" : "external",
-      naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
-      publicPath: this.#routePrefix,
-      metafile: true,
-      env: "AKAN_PUBLIC_*",
-      define: this.#context.define,
-      optimizeImports: this.#context.optimizeImports,
-      plugins: [this.#registryPlugin(vendor, misses)],
-    });
+    let result: Awaited<ReturnType<typeof Bun.build>>;
+    try {
+      result = await Bun.build({
+        entrypoints: files,
+        root: this.#paths.root,
+        target: "browser",
+        format: "cjs",
+        reactFastRefresh: !vendor,
+        sourcemap: vendor ? "none" : "external",
+        naming: { entry: "[dir]/[name].[ext]", asset: "assets/[name]-[hash].[ext]" },
+        publicPath: this.#routePrefix,
+        metafile: true,
+        env: "AKAN_PUBLIC_*",
+        //? A factory runs as a classic script, where `import.meta` is a SyntaxError that takes the whole vendor file
+        //? down, and Bun's cjs output keeps `import.meta.env` and spells `import.meta.url` as this disk's `file://` path.
+        define: { ...this.#context.define, "import.meta": "__akanMeta" },
+        optimizeImports: this.#context.optimizeImports,
+        plugins: [this.#registryPlugin(vendor, misses)],
+      });
+    } catch (error) {
+      if (vendor && error instanceof AggregateError) return await this.#withoutFailed(files, error);
+      throw error;
+    }
     const { outputs } = result.metafile as unknown as OutputMetafile;
     const sourceMaps = new Map(
       result.outputs.filter((artifact) => artifact.kind === "sourcemap").map((artifact) => [artifact.path, artifact]),
@@ -177,12 +187,20 @@ export class CsrDevModuleCompiler {
       }
       const code = await artifact.text();
       const id = this.#paths.idOf(file);
+      const built = CsrDevModuleCompiler.#factory(id, code);
+      const problem = CsrDevFactoryCheck.problemOf(built.factory, built.helpers?.definition);
+      if (problem && !vendor)
+        throw new Error(`[csr-dev] ${id}: its factory does not parse as a classic script: ${problem}`);
+      if (problem) {
+        modules.push(this.#leftOut(file, problem));
+        continue;
+      }
       const sourceMap = sourceMaps.get(`${artifact.path}.map`);
       modules.push({
         id,
         file,
         vendor,
-        ...CsrDevModuleCompiler.#factory(id, code),
+        ...built,
         sourceMap: sourceMap ? this.#rebaseSourceMap(await sourceMap.text()) : undefined,
         deps: this.#emittedDeps(code),
         mtimeMs: mtimes.get(file) ?? CsrDevPaths.mtimeOf(file),
@@ -192,6 +210,50 @@ export class CsrDevModuleCompiler {
     return { modules, misses, tangled };
   }
 
+  //? A package file that cannot be a CommonJS factory would fail every module built beside it, and no save fixes a
+  //? package: it is left out and named in the log, and the module requiring it gets the reason. App code still fails.
+  async #withoutFailed(files: string[], error: AggregateError): Promise<BuildRound> {
+    const reasons = new Map<string, string[]>();
+    for (const message of error.errors as {
+      message?: unknown;
+      position?: { file?: unknown; line?: number } | null;
+    }[]) {
+      const file = message.position?.file;
+      if (typeof file !== "string" || !path.isAbsolute(file)) continue;
+      const real = CsrDevPaths.realpath(file);
+      const at = message.position?.line ? `:${message.position.line}` : "";
+      reasons.set(real, [...(reasons.get(real) ?? []), `${String(message.message)} (${this.#paths.idOf(real)}${at})`]);
+    }
+    const failed = new Set(files.filter((file) => reasons.has(CsrDevPaths.realpath(file))));
+    if (failed.size === 0) throw error;
+    const rest = files.filter((file) => !failed.has(file));
+    const round = rest.length > 0 ? await this.#bunBuild(rest, true) : { modules: [], misses: [], tangled: [] };
+    for (const file of failed) {
+      const text = (reasons.get(CsrDevPaths.realpath(file)) ?? []).join("; ");
+      const awaits = text.includes('"await" can only be used');
+      round.modules.push(
+        this.#leftOut(file, awaits ? `a top-level await, which a CommonJS factory cannot wait on: ${text}` : text),
+      );
+    }
+    return round;
+  }
+
+  #leftOut(file: string, problem: string): CsrDevCompiledModule {
+    const real = CsrDevPaths.realpath(file);
+    const id = this.#paths.idOf(real);
+    this.#app.logger.error(`[csr-dev] ${id} is left out of the dev registry: ${problem}`);
+    return {
+      id,
+      file: real,
+      vendor: true,
+      factory: CsrDevFactoryCheck.thrower(id, problem),
+      helpers: null,
+      deps: [],
+      mtimeMs: CsrDevPaths.mtimeOf(real),
+      hash: "",
+    };
+  }
+
   #registryPlugin(vendor: boolean, misses: string[]): BunPlugin {
     return {
       name: "akan-csr-registry",
@@ -214,7 +276,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) {
@@ -261,12 +323,20 @@ export class CsrDevModuleCompiler {
   // Every rewrite keeps the line count, so a module's source map still lines up inside the factory.
   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, "");
+    //? Bun keeps a package's `#!` line atop its output, where a script inside a function cannot have one.
+    let patched = code
+      .replace(/^#!/, "//")
+      .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`,
         );
@@ -275,8 +345,13 @@ export class CsrDevModuleCompiler {
     // re-running the store root is the whole update, and bubbling past it would only reach the page modules.
     if (CsrDevModuleCompiler.#storeRoot.test(id)) patched += "\nmodule.hot.accept();";
     const shared = CsrDevModuleCompiler.#shareHelpers(patched);
+    //? What `import.meta` is in a browser module: a `url` and no `env`, so `import.meta.env` checks (jotai, zustand)
+    //? branch as they do in the ESM bundle. On the header line, outside the preamble that modules share.
+    const meta = /(?<![\w$.])__akanMeta(?![\w$])/.test(patched)
+      ? ` var __akanMeta = { url: new URL(${JSON.stringify(id.startsWith("/") ? id : `/${id}`)}, self.location.href).href };`
+      : "";
     return {
-      factory: `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {\n${shared?.code ?? patched}\n}`,
+      factory: `function (require, module, exports, $RefreshReg$, $RefreshSig$, __akanImport) {${meta}\n${shared?.code ?? patched}\n}`,
       helpers: shared?.helpers ?? null,
     };
   }

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',