@akanjs/devkit 3.0.0-beta.17 → 3.0.0-beta.19

package/executors.test.ts

@@ -312,9 +312,17 @@ describe("Workspace and app executor environment contracts", () => {
     expect(env.AKAN_PUBLIC_SERVER_PORT).toBe("8285");
     expect(env.EXTRA).toBe("ok");
 
+    const shellOperationMode = process.env.AKAN_PUBLIC_OPERATION_MODE;
+    process.env.AKAN_PUBLIC_OPERATION_MODE = "local";
     const prepared = await app.prepareCommand("build");
+    const bakedOperationMode = process.env.AKAN_PUBLIC_OPERATION_MODE;
+    if (shellOperationMode === undefined) delete process.env.AKAN_PUBLIC_OPERATION_MODE;
+    else process.env.AKAN_PUBLIC_OPERATION_MODE = shellOperationMode;
+    expect(bakedOperationMode).toBeUndefined();
     expect(prepared.env.AKAN_COMMAND_TYPE).toBe("build");
     expect(prepared.env.AKAN_PUBLIC_BASE_PATHS).toBe("admin");
+    expect(prepared.env.AKAN_DATABASE_MODE).toBe("single");
+    expect(prepared.env.AKAN_DATABASE_MODES).toBe("single");
     // Bundling reads `process.env` through getPublicEnv and `define`s every AKAN_PUBLIC_* into a literal, so a
     // dev port published here would be baked into the artifact and outrank the PORT the container is run with.
     expect(process.env.AKAN_PUBLIC_APP_NAME).toBe("demo");
@@ -727,7 +735,7 @@ describe("Workspace and app executor environment contracts", () => {
     });
   });
 
-  test("accepts metadata route exports during page key discovery", async () => {
+  test("accepts head route exports during page key discovery", async () => {
     const root = await makeTempRoot();
     process.env.AKAN_PUBLIC_REPO_NAME = "repo";
     process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
@@ -737,24 +745,19 @@ describe("Workspace and app executor environment contracts", () => {
     await writeFile(path.join(root, "apps/demo/akan.config.ts"), "export default {};\n");
     await writeFile(
       path.join(root, "apps/demo/page/_layout.tsx"),
-      [
-        "export const head = null;",
-        "export const metadata = { title: 'Root' };",
-        "export default function Layout({ children }) { return children; }",
-        "",
-      ].join("\n"),
+      ["export const head = null;", "export default function Layout({ children }) { return children; }", ""].join("\n"),
     );
     await writeFile(
       path.join(root, "apps/demo/page/docs/_layout.tsx"),
       [
-        "export async function generateMetadata() { return { title: 'Docs' }; }",
+        "export async function generateHead() { return null; }",
         "export default function Layout({ children }) { return children; }",
         "",
       ].join("\n"),
     );
     await writeFile(
       path.join(root, "apps/demo/page/docs/intro.tsx"),
-      ["export const metadata = { title: 'Intro' };", "export default function Page() { return null; }", ""].join("\n"),
+      ["export const head = null;", "export default function Page() { return null; }", ""].join("\n"),
     );
 
     const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
@@ -767,7 +770,7 @@ describe("Workspace and app executor environment contracts", () => {
     ]);
   });
 
-  test("rejects conflicting metadata route exports during page key discovery", async () => {
+  test("rejects a metadata route export during page key discovery", async () => {
     const root = await makeTempRoot();
     process.env.AKAN_PUBLIC_REPO_NAME = "repo";
     process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
@@ -776,47 +779,16 @@ describe("Workspace and app executor environment contracts", () => {
     await mkdir(path.join(root, "apps/demo/page"), { recursive: true });
     await writeFile(path.join(root, "apps/demo/akan.config.ts"), "export default {};\n");
     await writeFile(
-      path.join(root, "apps/demo/page/conflict.tsx"),
-      [
-        "export const metadata = { title: 'Conflict' };",
-        "export function generateMetadata() { return { title: 'Conflict' }; }",
-        "export default function Page() { return null; }",
-        "",
-      ].join("\n"),
+      path.join(root, "apps/demo/page/legacy.tsx"),
+      ["export const metadata = { title: 'Legacy' };", "export default function Page() { return null; }", ""].join(
+        "\n",
+      ),
     );
 
     const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
     const app = AppExecutor.from(workspace, "demo");
 
-    await expect(app.getPageKeys({ refresh: true })).rejects.toThrow(
-      "metadata and generateMetadata cannot both be exported",
-    );
-  });
-
-  test("rejects mixed head and metadata route export channels during page key discovery", async () => {
-    const root = await makeTempRoot();
-    process.env.AKAN_PUBLIC_REPO_NAME = "repo";
-    process.env.AKAN_PUBLIC_SERVE_DOMAIN = "example.com";
-    process.env.AKAN_PUBLIC_ENV = "local";
-    await writeJson(path.join(root, "package.json"), rootPackageJson());
-    await mkdir(path.join(root, "apps/demo/page"), { recursive: true });
-    await writeFile(path.join(root, "apps/demo/akan.config.ts"), "export default {};\n");
-    await writeFile(
-      path.join(root, "apps/demo/page/mixed.tsx"),
-      [
-        "export const head = null;",
-        "export const metadata = { title: 'Mixed' };",
-        "export default function Page() { return null; }",
-        "",
-      ].join("\n"),
-    );
-
-    const workspace = new WorkspaceExecutor({ workspaceRoot: root, repoName: "repo" });
-    const app = AppExecutor.from(workspace, "demo");
-
-    await expect(app.getPageKeys({ refresh: true })).rejects.toThrow(
-      "head/generateHead and metadata/generateMetadata cannot both be exported",
-    );
+    await expect(app.getPageKeys({ refresh: true })).rejects.toThrow('unsupported export "metadata"');
   });
 
   test("assigns start command ports from sorted app order", async () => {

package/executors.ts

@@ -11,6 +11,7 @@ import { readFileSync } from "node:fs";
 import {
   copyFile,
   cp as cpEntry,
+  lstat,
   mkdir,
   readdir as readDirEntries,
   realpath,
@@ -96,7 +97,9 @@ const staticTemplateFileExtensions = new Set([
   ".xml",
 ]);
 
-const formatCommandArg = (value: string) => (/^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value));
+//? A backslash is a path separator on Windows but an escape in a POSIX shell, so only there does it force quoting.
+const plainCommandArgPattern = process.platform === "win32" ? /^[\w@%+=:,./\\-]+$/ : /^[\w@%+=:,./-]+$/;
+const formatCommandArg = (value: string) => (plainCommandArgPattern.test(value) ? value : JSON.stringify(value));
 
 const formatCommandForDisplay = (command: string, args: string[] = []) =>
   [command, ...args].map(formatCommandArg).join(" ");
@@ -475,8 +478,10 @@ export class Executor {
     const isDirectory = (await stat(src)).isDirectory();
     if (!(await FileSys.exists(dest)) && isDirectory) await mkdir(dest, { recursive: true });
     //* `cp -r` keeps symlinks on GNU coreutils but follows them on macOS, so anything that must land as
-    //* real files regardless of platform has to say so explicitly.
-    if (dereference) await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
+    //* real files regardless of platform has to say so explicitly. Windows has no `cp -r <dir>/.` and a
+    //* symlink there needs a privilege most accounts lack, so it always lands as real files.
+    if (dereference || process.platform === "win32")
+      await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
     else await $`cp -r ${src}${isDirectory ? "/." : ""} ${dest}`;
   }
   log(msg: string) {
@@ -1405,14 +1410,21 @@ export class AppExecutor extends SysExecutor {
       ...env,
     };
   }
+  /** The database mode a command runs this app in, and the modes its build carries — the same rule the server boots by. */
+  async getDatabaseModeEnv() {
+    const akanConfig = await this.getConfig();
+    return {
+      AKAN_DATABASE_MODE: akanConfig.resolveDatabaseMode(),
+      AKAN_DATABASE_MODES: akanConfig.database.modes.join(","),
+    };
+  }
   async prepareCommand(type: "build" | "start") {
     const akanConfig = await this.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
     const routeEnv = {
       AKAN_PUBLIC_BASE_PATHS: [...akanConfig.basePaths].join(","),
       AKAN_PUBLIC_API_PREFIX: akanConfig.api.prefix,
       AKAN_PUBLIC_WS_PREFIX: akanConfig.api.websocketPrefix,
-      AKAN_DATABASE_MODE: databaseMode,
+      ...(await this.getDatabaseModeEnv()),
     };
     Object.assign(process.env, routeEnv);
     if (type === "build") {
@@ -1457,11 +1469,14 @@ export class AppExecutor extends SysExecutor {
     // this does not leak non-public env.
     // The port keys are this machine's dev allocation, and `define` turns an `AKAN_PUBLIC_*` into a literal the
     // artifact can never be run with a different value for — a baked port would outrank the `PORT` the container
-    // is started with and send every SSR self-call to a port nothing bound.
+    // is started with and send every SSR self-call to a port nothing bound. The operation mode likewise: one image
+    // serves an edge site and a cloud cluster, and a shell's `local` would pin every artifact to it.
     if (type === "build") {
       const buildEnv = { ...env };
       delete buildEnv.AKAN_PUBLIC_CLIENT_PORT;
       delete buildEnv.AKAN_PUBLIC_SERVER_PORT;
+      delete buildEnv.AKAN_PUBLIC_OPERATION_MODE;
+      delete process.env.AKAN_PUBLIC_OPERATION_MODE;
       Object.assign(process.env, buildEnv);
     }
     return { env };
@@ -1507,7 +1522,9 @@ export class AppExecutor extends SysExecutor {
     const owners = new Map<string, { absPath: string; fromLib: boolean }>();
     const devOnlyKeys = new Set<string>();
     const devOnlyDirs: string[] = [];
-    for (const root of await this.getPageRoots()) {
+    const pageRoots = await this.getPageRoots();
+    const libKeyPrefixes = pageRoots.map((root) => root.keyPrefix).filter(Boolean);
+    for (const root of pageRoots) {
       if (!(await FileSys.dirExists(root.dir))) continue;
       for await (const rel of glob.scan({
         cwd: root.dir,
@@ -1517,6 +1534,8 @@ export class AppExecutor extends SysExecutor {
         const segments = rel.split(path.sep);
         if (segments.some((s) => s === "node_modules")) continue;
         const posix = `${root.keyPrefix}${segments.join("/")}`;
+        //* A lib folder that is a copy rather than a link (the Windows fallback) is walked into from `page` too.
+        if (!root.keyPrefix && libKeyPrefixes.some((prefix) => posix.startsWith(prefix))) continue;
         const absPath = path.join(root.dir, ...segments);
         validatePageSourceFile(posix, { filePath: absPath });
         if (!isRouteSourceFile(posix)) continue;
@@ -1619,7 +1638,11 @@ export class AppExecutor extends SysExecutor {
       )
     ).flat();
     const wanted = parents.flatMap((parent) => libs.map((lib) => `${parent}${AppExecutor.#pageLibsDir}/(${lib})/`));
-    if (linked.sort().join(",") === wanted.sort().join(",")) return false;
+    //* A copy — the Windows fallback when a junction is refused — does not follow its lib, so only links are current.
+    const isLink = async (key: string) =>
+      (await lstat(`${this.cwdPath}/page/${key.slice(0, -1)}`).catch(() => null))?.isSymbolicLink() ?? false;
+    if (linked.sort().join(",") === wanted.sort().join(",") && (await Promise.all(linked.map(isLink))).every(Boolean))
+      return false;
     await Promise.all(
       parents.map((parent) => this.removeDir(`${this.cwdPath}/page/${parent}${AppExecutor.#pageLibsDir}`)),
     );

package/frontendBuild/autoImportSync.test.ts

@@ -161,6 +161,19 @@ describe("transformSource — client role (package client entry)", () => {
     );
   });
 
+  test("never claims fetch from a file that calls the platform fetch", () => {
+    const globalOnly = `"use client";\n\nexport const toBlob = async (url: string) => await (await fetch(url)).blob();\n`;
+    const mixed = `"use client";\n\nexport const C = async (url: string) => (await fetch(url)).ok && fetch.me() && st.foo;\n`;
+    const passed = `"use client";\n\nexport const load = (get = fetch) => get("/a");\n`;
+
+    expect(transformSource(globalOnly, "CropImage.tsx", clientLibCtx)).toBeNull();
+    expect(transformSource(mixed, "C.Zone.tsx", clientLibCtx)).toBe(
+      `"use client";\nimport { st } from "@libs/shared/client";\n\nexport const C = async (url: string) => (await fetch(url)).ok && fetch.me() && st.foo;\n`,
+    );
+    expect(transformSource(passed, "load.ts", clientLibCtx)).toBeNull();
+    expect(transformSource(globalOnly, "x.store.ts", storeCtx)).toBeNull();
+  });
+
   test("handles webkit .ts files (no jsx) the same as tsx", () => {
     const source = `import { getEnv } from "akanjs/base";\n\nexport const load = () => fetch.me();\n`;
     const out = transformSource(source, "cookie.ts", clientLibCtx);

package/frontendBuild/autoImportSync.ts

@@ -161,6 +161,10 @@ const LIB_BARRELS: Record<string, { barrel: string; kind: ImportKind }> = {
   cnst: { barrel: "cnst", kind: "namespace" },
   srv: { barrel: "srv", kind: "namespace" },
 };
+//* Registry names that are also runtime globals. An unbound `fetch(url)` is the platform's fetch, and importing Akan's
+//* over it silently rebinds the call, so such a name is claimed only when every reference has the Akan member shape
+//* (`fetch.viewX()`); one bare use leaves the file alone.
+const GLOBAL_NAMES = new Set(["fetch"]);
 //* ECMAScript/TS structural globals never resolved as domain symbols, so that a package model named
 //* e.g. `Map` cannot shadow the JS `Map` used in `new Map()`. Domain-y globals like `File` are allowed
 //* on purpose (they are real models here).
@@ -378,13 +382,14 @@ export const transformSource = (
   const sf = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, scriptKindFor(fileName));
   const bound = collectBoundNames(sf);
   const used = collectUsedReferences(sf);
+  const bareGlobals = collectBareGlobalReferences(sf);
 
   // Group the needed symbols by their import target: framework registry first, then dynamic resolver.
   // Named groups map each name to whether it is type-only, so we can emit `import type`/inline `type`.
   const namedBySpecifier = new Map<string, Map<string, boolean>>();
   const namespaceImports: { name: string; specifier: string }[] = [];
   for (const name of used) {
-    if (bound.has(name)) continue;
+    if (bound.has(name) || bareGlobals.has(name)) continue;
     const target = targetFor(name, ctx) ?? resolveExtra?.(name) ?? null;
     if (!target) continue;
     if (target.kind === "namespace") namespaceImports.push({ name, specifier: target.specifier });
@@ -478,6 +483,19 @@ const collectUsedReferences = (sf: ts.SourceFile): Set<string> => {
   return used;
 };
 
+const collectBareGlobalReferences = (sf: ts.SourceFile): Set<string> => {
+  const bare = new Set<string>();
+  const visit = (node: ts.Node) => {
+    if (ts.isIdentifier(node) && GLOBAL_NAMES.has(node.text) && isReferencePosition(node)) {
+      const parent = node.parent;
+      if (!(parent && ts.isPropertyAccessExpression(parent) && parent.expression === node)) bare.add(node.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sf, visit);
+  return bare;
+};
+
 //* True when the identifier reads a binding, as opposed to being a member name, property key, or
 //* declaration name. e.g. in `cnst.Coordinate`, `cnst` is a reference but `Coordinate` is not.
 const isReferencePosition = (node: ts.Identifier): boolean => {

package/frontendBuild/buildRouteClient.test.ts

@@ -27,7 +27,7 @@ afterEach(async () => {
 
 describe("route client store bootstrap", () => {
   test("wraps client entries with app client bootstrap before re-exporting components", () => {
-    const original = "/repo/pkgs/akanjs/ui/Model/NewWrapper_Client.tsx";
+    const original = path.resolve("/repo/pkgs/akanjs/ui/Model/NewWrapper_Client.tsx");
     const source = RouteClientBuilder.createStoreBootstrapEntrySource({
       appName: "akan",
       originalEntry: original,
@@ -147,6 +147,57 @@ describe("route client store bootstrap", () => {
     );
   });
 
+  test("bundles every route's entries into one graph so a page never loads a module twice", async () => {
+    const root = await makeTempRoot();
+    const appDir = path.join(root, "apps/demo");
+    const pageA = path.join(appDir, "page/a.tsx");
+    const pageB = path.join(appDir, "page/b.tsx");
+    const entryA = path.join(appDir, "ui/A.tsx");
+    const entryB = path.join(appDir, "ui/B.tsx");
+    const shared = path.join(appDir, "common/shared.ts");
+    await write(pageA, 'import { A } from "../ui/A";\nexport default A;\n');
+    await write(pageB, 'import { B } from "../ui/B";\nexport default B;\n');
+    await write(entryA, '"use client";\nimport { mark } from "../common/shared";\nexport const A = () => mark;\n');
+    await write(entryB, '"use client";\nimport { mark } from "../common/shared";\nexport const B = () => mark;\n');
+    await write(shared, 'export const mark = "shared-module-marker";\n');
+    const app = {
+      name: "demo",
+      cwdPath: appDir,
+      dist: { cwdPath: path.join(root, "dist/apps/demo") },
+      workspace: { workspaceRoot: root },
+      getConfig: async () => ({ barrelImports: [], optimizeImports: [] }),
+      getTsConfig: async () => ({ compilerOptions: { paths: {} } }),
+      getPublicEnv: () => ({}),
+    } as never;
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, async () => null);
+    const build = (seeds: string[], knownEntries: Set<string>) =>
+      new RouteClientBuilder({
+        app,
+        seeds,
+        graphSeeds: [pageA, pageB],
+        knownEntries,
+        discovery,
+        artifact: {} as never,
+      }).build();
+
+    const first = await build([pageA], new Set());
+    const second = await build([pageB], new Set(first.newEntries));
+
+    expect(first.newEntries).toEqual([entryA, entryB]);
+    expect(first.discoveredEntries).toEqual([entryA]);
+    expect(first.clientDeps).not.toContain(entryB);
+    expect(Object.keys(first.clientDepsByEntry ?? {}).sort()).toEqual([entryA, entryB]);
+    expect(second.newEntries).toEqual([]);
+    expect(second.discoveredEntries).toEqual([entryB]);
+    expect(Object.keys(second.manifestDelta)).toEqual([]);
+    const clientOut = path.join(appDir, ".akan/artifact/client");
+    const outputs = [...new Bun.Glob("**/*.js").scanSync(clientOut)];
+    const carriers = await Promise.all(
+      outputs.map(async (file) => (await Bun.file(path.join(clientOut, file)).text()).includes("shared-module-marker")),
+    );
+    expect(carriers.filter(Boolean)).toHaveLength(1);
+  });
+
   test("discovers client entries from installed akanjs package sources", async () => {
     const root = await makeTempRoot();
     const seed = path.join(root, "apps/demo/page/_index.tsx");

package/frontendBuild/cssImportResolver.ts

@@ -135,7 +135,7 @@ export class CssImportResolver {
 
   async #firstExisting(basePath: string): Promise<string | null> {
     for (const suffix of CSS_IMPORT_EXTS) {
-      const candidate = `${basePath}${suffix}`;
+      const candidate = path.normalize(`${basePath}${suffix}`);
       if (await Bun.file(candidate).exists()) return candidate;
     }
     return null;

package/frontendBuild/fontOptimizer.test.ts

@@ -170,7 +170,7 @@ describe("FontOptimizer discovery", () => {
     expect(result.fonts).toEqual([]);
     expect(result.files).toEqual([]);
     expect(warnings).toHaveLength(1);
-    expect(warnings[0]).toContain("page/_layout.tsx");
+    expect(warnings[0]).toContain(path.join("page", "_layout.tsx"));
   });
 
   test("warns about an entry it cannot read and keeps the ones it can", async () => {

package/frontendBuild/frontendBuild.test.ts

@@ -333,13 +333,14 @@ describe("RoutesManifestArtifactSerializer", () => {
 describe("HmrChangeClassifier", () => {
   test("classifies code, css, config, and ignored files", () => {
     const classifier = new HmrChangeClassifier();
-    expect(classifier.classify("/repo/apps/demo/page/_index.tsx")).toBe("code");
-    expect(classifier.classify("/repo/apps/demo/page/styles.css")).toBe("css");
-    expect(classifier.classify("/repo/apps/demo/akan.config.ts")).toBe("config");
-    expect(classifier.classify("/repo/apps/demo/.DS_Store")).toBe("ignore");
-    expect(classifier.classify(`/repo/apps/demo/node_modules/pkg/index.ts`)).toBe("ignore");
-    expect(classifier.classify(`/repo/apps/demo/.akan/generated/page.tsx`)).toBe("ignore");
-    expect(classifier.classify("/repo/apps/demo/public/logo.png")).toBe("ignore");
+    const app = path.resolve("/repo/apps/demo");
+    expect(classifier.classify(path.join(app, "page/_index.tsx"))).toBe("code");
+    expect(classifier.classify(path.join(app, "page/styles.css"))).toBe("css");
+    expect(classifier.classify(path.join(app, "akan.config.ts"))).toBe("config");
+    expect(classifier.classify(path.join(app, ".DS_Store"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, "node_modules/pkg/index.ts"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, ".akan/generated/page.tsx"))).toBe("ignore");
+    expect(classifier.classify(path.join(app, "public/logo.png"))).toBe("ignore");
   });
 });
 
@@ -394,16 +395,16 @@ describe("DevGeneratedIndexSync", () => {
 
 describe("DevChangePlanner", () => {
   test("classifies server, client, shared, and generated barrel changes", () => {
-    const root = "/repo";
+    const root = path.resolve("/repo");
     const planner = new DevChangePlanner({ workspaceRoot: root });
-    const generatedIndex = `${root}/libs/shared/common/index.ts`;
+    const generatedIndex = path.join(root, "libs/shared/common/index.ts");
     const plan = planner.plan({
       generation: 7,
       files: [
-        `${root}/libs/shared/lib/admin/admin.service.ts`,
-        `${root}/libs/shared/lib/admin/Admin.Template.tsx`,
-        `${root}/libs/shared/lib/admin/admin.constant.ts`,
-        `${root}/libs/shared/common/foo.ts`,
+        path.join(root, "libs/shared/lib/admin/admin.service.ts"),
+        path.join(root, "libs/shared/lib/admin/Admin.Template.tsx"),
+        path.join(root, "libs/shared/lib/admin/admin.constant.ts"),
+        path.join(root, "libs/shared/common/foo.ts"),
       ],
       kinds: ["code"],
       generatedFiles: [generatedIndex],
@@ -429,21 +430,22 @@ describe("DevChangePlanner", () => {
   });
 
   test("recycles builder for macro-backed dictionary and signal metadata changes", () => {
-    const root = "/repo";
+    const root = path.resolve("/repo");
     const planner = new DevChangePlanner({ workspaceRoot: root });
+    const dictionaryFile = path.join(root, "apps/demo/lib/_demo/demo.dictionary.ts");
     const dictionaryPlan = planner.plan({
       generation: 3,
-      files: [`${root}/apps/demo/lib/_demo/demo.dictionary.ts`],
+      files: [dictionaryFile],
       kinds: ["code"],
     });
     const signalPlan = planner.plan({
       generation: 4,
-      files: [`${root}/libs/shared/lib/admin/admin.signal.ts`],
+      files: [path.join(root, "libs/shared/lib/admin/admin.signal.ts")],
       kinds: ["code"],
     });
 
     expect(dictionaryPlan.actions).toEqual(["rebuild-client", "restart-backend", "restart-builder"]);
-    expect(dictionaryPlan.reasonByFile[`${root}/apps/demo/lib/_demo/demo.dictionary.ts`]).toContain("runtime-metadata");
+    expect(dictionaryPlan.reasonByFile[dictionaryFile]).toContain("runtime-metadata");
     expect(signalPlan.actions).toContain("restart-builder");
   });
 });

package/frontendBuild/hmrWatcher.test.ts

@@ -161,7 +161,7 @@ describe("HmrWatcher", () => {
     TEST_TIMEOUT_MS,
   );
 
-  test.skipIf(process.getuid?.() === 0)(
+  test.skipIf(process.getuid?.() === 0 || process.platform === "win32")(
     "warns at startup when part of the tree cannot be read",
     async () => {
       const root = await makeRoot();

package/frontendBuild/routeClientBuilder.ts

@@ -28,6 +28,15 @@ const SSR_CLIENT_ALIAS_EXTERNALS = [
 export interface BuildRouteClientOptions {
   app: App;
   seeds: string[];
+  /**
+   * Seeds of every route, so a build that has to run at all bundles the whole app's client entries.
+   *
+   * A page loads entries first built for other routes, and entries from two `Bun.build` runs each carry
+   * their own copy of every app and lib module — one page evaluated a lib's module-scope registration
+   * twice. The whole app costs about what one route did, since every entry already imports the client
+   * barrel, and content-hashed chunk names keep unchanged chunks at the URLs the browser already holds.
+   */
+  graphSeeds?: string[];
   artifact: BaseBuildArtifact;
   knownEntries?: Set<string>;
   routeId?: string;
@@ -39,13 +48,13 @@ export interface BuildRouteClientOptions {
    * `AllRoutesBuilder` passes every route's entries at once so they share one `Bun.build`. Chunk
    * splitting is scoped to a single invocation, so a dependency reachable from entries spread across
    * several invocations is emitted once per invocation — mermaid landed in `apps/akan` four times that
-   * way. Dev keeps one build per route and leaves this unset.
+   * way. Dev passes `graphSeeds` instead, for the same reason.
    */
   entries?: string[];
 }
 
 export interface BuildRouteClientResult {
-  /** Newly-emitted manifest rows keyed by `${absEntry}#${exportName}`. */
+  /** Newly-emitted manifest rows keyed by `${absEntry}#${exportName}`, for every entry this build bundled. */
   manifestDelta: ClientManifest;
   /** Newly-emitted ssrManifest rows keyed by entry URL. */
   ssrManifestDelta: SsrManifest;
@@ -53,7 +62,7 @@ export interface BuildRouteClientResult {
   newEntries: string[];
   /** Absolute paths of all `"use client"` leaves discovered from this route's seeds. */
   discoveredEntries?: string[];
-  /** Absolute source files included in the browser bundles for new entries. */
+  /** Absolute source files included in the browser bundles for this route's bundled entries. */
   clientDeps: string[];
   /** Absolute source files included in the browser bundle, grouped by original client entry. */
   clientDepsByEntry?: Record<string, string[]>;
@@ -67,6 +76,7 @@ interface BootstrapEntries {
 export class RouteClientBuilder {
   #app: App;
   #seeds: string[];
+  #graphSeeds?: string[];
   #knownEntries: Set<string>;
   #command: "build" | "start";
   #discovery?: ClientEntryDiscovery;
@@ -75,6 +85,7 @@ export class RouteClientBuilder {
   constructor(options: BuildRouteClientOptions) {
     this.#app = options.app;
     this.#seeds = options.seeds;
+    this.#graphSeeds = options.graphSeeds;
     this.#knownEntries = options.knownEntries ?? new Set<string>();
     this.#command = options.command ?? "start";
     this.#discovery = options.discovery;
@@ -82,17 +93,18 @@ export class RouteClientBuilder {
   }
 
   async build(): Promise<BuildRouteClientResult> {
-    const discovered =
-      this.#entries ??
-      (await (this.#discovery ?? (await GraphClientEntryDiscovery.create(this.#app))).discover(this.#seeds));
-    const entries = discovered.filter((e) => !this.#knownEntries.has(e));
-    if (entries.length === 0) return this.#emptyResult(discovered);
+    const discovered = this.#entries ?? (await (await this.#getDiscovery()).discover(this.#seeds));
+    if (discovered.every((e) => this.#knownEntries.has(e))) return this.#emptyResult(discovered);
+    const entries = this.#graphSeeds
+      ? [...new Set([...discovered, ...(await (await this.#getDiscovery()).discover(this.#graphSeeds))])].sort()
+      : discovered.filter((e) => !this.#knownEntries.has(e));
 
     const bootstrapEntries = await this.#createBootstrapEntries(entries);
     const browserBundle = await this.#buildBrowserBundle(bootstrapEntries);
     const ssrBundle = await this.#buildSsrBundle(bootstrapEntries);
 
     const acceptedEntries = new Set(entries);
+    const routeEntries = new Set(discovered);
     const manifestDelta: ClientManifest = {};
     const ssrModuleMap: SsrManifest["moduleMap"] = {};
     const clientDeps = new Set<string>();
@@ -122,19 +134,24 @@ export class RouteClientBuilder {
       for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? []) deps.add(path.resolve(dep));
       const sortedDeps = [...deps].sort();
       clientDepsByEntry[originalEntry] = sortedDeps;
-      for (const dep of sortedDeps) clientDeps.add(dep);
+      if (routeEntries.has(originalEntry)) for (const dep of sortedDeps) clientDeps.add(dep);
     }
 
     return {
       manifestDelta,
       ssrManifestDelta: { moduleLoading: null, moduleMap: ssrModuleMap },
-      newEntries: entries,
+      newEntries: entries.filter((e) => !this.#knownEntries.has(e)),
       discoveredEntries: discovered,
       clientDeps: [...clientDeps].sort(),
       clientDepsByEntry,
     };
   }
 
+  async #getDiscovery(): Promise<ClientEntryDiscovery> {
+    this.#discovery ??= await GraphClientEntryDiscovery.create(this.#app);
+    return this.#discovery;
+  }
+
   #emptyResult(discoveredEntries: string[] = []): BuildRouteClientResult {
     return {
       manifestDelta: {},

package/frontendBuild/sourceMtimeIndex.test.ts

@@ -249,11 +249,12 @@ describe("SourceMtimeIndex", () => {
   describe("a directory it cannot read", () => {
     /**
      * `chmod 000` does not stop root, so these would assert the opposite of what they mean when the suite
-     * runs as root (CI containers commonly do).
+     * runs as root (CI containers commonly do). On Windows it only sets the read-only attribute, which leaves
+     * a directory listable.
      */
-    const asRoot = process.getuid?.() === 0;
+    const cannotLock = process.getuid?.() === 0 || process.platform === "win32";
 
-    test.skipIf(asRoot)("is reported as a gap instead of silently skipped", async () => {
+    test.skipIf(cannotLock)("is reported as a gap instead of silently skipped", async () => {
       const root = await makeRoot();
       await seed(root, "open/a.ts");
       const hidden = await seed(root, "locked/b.ts");
@@ -269,7 +270,7 @@ describe("SourceMtimeIndex", () => {
       expect(index.coverageGaps).toEqual([{ path: path.dirname(hidden), code: "EACCES" }]);
     });
 
-    test.skipIf(asRoot)("becomes visible again once it is readable, and clears the gap", async () => {
+    test.skipIf(cannotLock)("becomes visible again once it is readable, and clears the gap", async () => {
       const root = await makeRoot();
       const hidden = await seed(root, "locked/b.ts");
       const locked = path.dirname(hidden);
@@ -287,7 +288,7 @@ describe("SourceMtimeIndex", () => {
       expect(await index.collectChanges()).toEqual([hidden]);
     });
 
-    test.skipIf(asRoot)("does not report the files under it as deleted while it is unreadable", async () => {
+    test.skipIf(cannotLock)("does not report the files under it as deleted while it is unreadable", async () => {
       const root = await makeRoot();
       const abs = await seed(root, "locked/b.ts");
       const locked = path.dirname(abs);

package/getDirname.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import path from "node:path";
+import { pathToFileURL } from "node:url";
 import { getDirname } from "./getDirname";
 
 describe("getDirname", () => {
   test("converts file URLs to filesystem paths", () => {
-    const dirname = getDirname("file:///tmp/akan%20workspace/index.ts");
+    const filePath = path.resolve("/tmp/akan workspace/index.ts");
+    const dirname = getDirname(pathToFileURL(filePath).href);
 
-    expect(dirname).toBe(path.join("/tmp", "akan workspace"));
+    expect(dirname).toBe(path.dirname(filePath));
   });
 
   test("keeps Windows drive paths valid when running on Windows", () => {