@akanjs/devkit 3.2.0-rc.3 → 3.2.0-rc.6

package/commandDecorators/command.ts

@@ -9,7 +9,15 @@ import { Logger } from "akanjs/common";
 import chalk from "chalk";
 import { type Command, program } from "commander";
 import { AppSelectionMemory } from "../appSelectionMemory";
-import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
+import {
+  AppExecutor,
+  Executor,
+  LibExecutor,
+  ModuleExecutor,
+  PkgExecutor,
+  type SysExecutor,
+  WorkspaceExecutor,
+} from "../executors";
 // Never the root barrel: it drags ink, ssh2 and the cloud stack into every command process.
 import { FileSys, getDirname } from "../fileSys";
 import type { PackageJson } from "../types";
@@ -311,6 +319,17 @@ export const getInternalArgumentValue = async (
     if (destructive) throw refusalOf(problemOf(kind), "this command deletes files and never picks its target", refusal);
     assertPromptable(problemOf(kind), refusal);
   };
+  const takeOnly = <Target>(kind: string, names: readonly string[], take: (name: string) => Target) => {
+    const [only] = names;
+    if (value || destructive || process.stdin.isTTY || names.length !== 1 || !only) return null;
+    const how = rerun ? `: ${rerun(only)}` : "";
+    Logger.rawLog(
+      `No ${kind} named, so this runs on '${only}', the only one in this workspace${how}`,
+      undefined,
+      "error",
+    );
+    return take(only);
+  };
   if (sysType === "sys" || sysType === "exec") {
     const pkgChoices = sysType === "exec" ? pkgNames : [];
     const execOf = (name: string) => {
@@ -326,17 +345,8 @@ export const getInternalArgumentValue = async (
     const [kind, placeholder] =
       sysType === "exec" ? ["app, lib or pkg", "<app-lib-or-pkg>"] : ["app or lib", "<app-or-lib>"];
     const choices = [...appNames, ...libNames, ...pkgChoices];
-    const only = choices.length === 1 ? execOf(choices[0] ?? "") : null;
-    //? Not for Lib, Pkg or Module, which name what a command acts on: `akan remove-library` would delete the only one.
-    if (!value && !destructive && only && !process.stdin.isTTY) {
-      const how = rerun ? `: ${rerun(only.name)}` : "";
-      Logger.rawLog(
-        `No ${kind} named, so this runs on '${only.name}', the only one in this workspace${how}`,
-        undefined,
-        "error",
-      );
-      return only;
-    }
+    const only = takeOnly(kind, choices, execOf);
+    if (only) return only;
     assertAskable(kind, choices, placeholder);
     const name = await select<string>({
       message: sysType === "exec" ? `Select the App or Lib or Pkg name` : `Select the App or Lib name`,
@@ -353,40 +363,48 @@ export const getInternalArgumentValue = async (
     return AppExecutor.from(workspace, appName);
   } else if (sysType === "lib") {
     if (value && libNames.includes(value)) return LibExecutor.from(workspace, value);
+    const only = takeOnly("lib", libNames, (name) => LibExecutor.from(workspace, name));
+    if (only) return only;
     assertAskable("lib", libNames, "<lib>");
     const libName = await select<string>({ message: `Select the ${sysType} name`, choices: libNames });
     return LibExecutor.from(workspace, libName);
   } else if (sysType === "pkg") {
     const pkgs = await workspace.getPkgs();
     if (value && pkgs.includes(value)) return PkgExecutor.from(workspace, value);
+    const only = takeOnly("pkg", pkgs, (name) => PkgExecutor.from(workspace, name));
+    if (only) return only;
     assertAskable("pkg", pkgs, "<pkg>");
     const pkgName = await select<string>({ message: `Select the ${sysType} name`, choices: pkgs });
     return PkgExecutor.from(workspace, pkgName);
   } else if (sysType === "module") {
-    if (value) {
-      const [sysName, moduleName] = value.split(":");
-      if (!sysName || !moduleName) throw new Error(`Invalid module name: ${value}`);
-      if (appNames.includes(sysName)) {
-        const app = AppExecutor.from(workspace, sysName);
-        const modules = await app.getModules();
-        if (modules.includes(moduleName)) return ModuleExecutor.from(app, moduleName);
-        else throw new Error(`Invalid module name: ${moduleName}`);
-      } else if (libNames.includes(sysName)) {
-        const lib = LibExecutor.from(workspace, sysName);
-        const modules = await lib.getModules();
-        if (modules.includes(moduleName)) return ModuleExecutor.from(lib, moduleName);
-      } else throw new Error(`Invalid system name: ${sysName}`);
-    }
     const systems = [
       ...appNames.map((name) => AppExecutor.from(workspace, name)),
       ...libNames.map((name) => LibExecutor.from(workspace, name)),
     ];
-    const choices =
-      process.stdin.isTTY && !destructive
-        ? []
-        : (
-            await Promise.all(systems.map(async (sys) => (await sys.getModules()).map((m) => `${sys.name}:${m}`)))
-          ).flat();
+    const modulesOf = async (sys: SysExecutor) => [
+      ...(await sys.getModules()),
+      ...(argMeta.option?.services ? await sys.getServiceModules() : []),
+    ];
+    const listModules = async () =>
+      (await Promise.all(systems.map(async (sys) => (await modulesOf(sys)).map((m) => `${sys.name}:${m}`)))).flat();
+    if (value) {
+      const [sysName, moduleName] = value.split(":");
+      if (!sysName || !moduleName) throw new Error(`Invalid module name: ${value}`);
+      const sys = systems.find((each) => each.name === sysName);
+      if (!sys) throw new Error(`Invalid system name: ${sysName}`);
+      if ((await modulesOf(sys)).includes(moduleName)) return ModuleExecutor.from(sys, moduleName);
+      throw refusalOf(problemOf("module"), `${sysName} has no such module`, {
+        choices: await listModules(),
+        ...rerunRemedyOf(rerun, "<sys:module>"),
+      });
+    }
+    const choices = process.stdin.isTTY && !destructive ? [] : await listModules();
+    const only = takeOnly("module", choices, (label) => {
+      const [sysName, moduleName = ""] = label.split(":");
+      const sys = systems.find((each) => each.name === sysName);
+      return sys ? ModuleExecutor.from(sys, moduleName) : null;
+    });
+    if (only) return only;
     assertAskable("module", choices, "<sys:module>");
     const { type, name } = await select<{ type: "app" | "lib"; name: string }>({
       message: `select the App or Lib name`,
@@ -396,7 +414,7 @@ export const getInternalArgumentValue = async (
       ],
     });
     const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
-    const modules = await executor.getModules();
+    const modules = await modulesOf(executor);
     const moduleName = await select<string>({
       message: `Select the module name`,
       choices: modules.map((name) => ({ name: `${executor.name}:${name}`, value: name })),

package/commandDecorators/commandDecorators.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import path from "node:path";
-import { AppExecutor, LibExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
+import { AppExecutor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
 import { makeCliTempWorkspace, tempRoots, writeText } from "../testHelpers";
 import {
   App,
@@ -440,6 +440,7 @@ describe("enum arg type inference", () => {
 
 describe("a Sys that defaults to the only app", () => {
   const ownIsTTY = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
+  const ownCwd = process.cwd();
   const asked: unknown[] = [];
   let answer = "";
   const setTTY = (isTTY: boolean | undefined) =>
@@ -455,6 +456,7 @@ describe("a Sys that defaults to the only app", () => {
   });
   afterEach(() => {
     CommandContainer.clear();
+    process.chdir(ownCwd);
     if (ownIsTTY) Object.defineProperty(process.stdin, "isTTY", ownIsTTY);
     else Reflect.deleteProperty(process.stdin, "isTTY");
   });
@@ -476,6 +478,21 @@ describe("a Sys that defaults to the only app", () => {
     if (!meta) throw new Error(`no Sys meta on ${key}`);
     return meta;
   };
+  const track = tempRoots();
+  //? From the workspace root, as the CLI runs: getDirInModule stats its entries relative to the process directory.
+  const moduleWorkspace = async () => {
+    const { root, workspace } = track(await makeCliTempWorkspace());
+    process.chdir(root);
+    for (const [sys, name] of [
+      ["apps/web", "card"],
+      ["libs/util", "photo"],
+    ] as const) {
+      await writeText(path.join(root, sys, "akan.config.ts"), "export default {};\n");
+      await writeText(path.join(root, sys, "lib", name, `${name}.constant.ts`), "export {};\n");
+    }
+    await writeText(path.join(root, "apps/web/lib/_billing/billing.service.ts"), "export {};\n");
+    return workspace;
+  };
 
   test("the opted-in command takes a one-app workspace's app without asking, even on a piped stdin", async () => {
     setTTY(undefined);
@@ -525,19 +542,24 @@ describe("a Sys that defaults to the only app", () => {
     expect(asked).toEqual([]);
   });
 
-  test("without a terminal, the only lib, pkg or module is not taken, as a command may be removing it", async () => {
+  test("without a terminal, a command that deletes nothing takes the only lib, pkg or module; a terminal is asked", async () => {
     setTTY(undefined);
     const workspace = workspaceWith([]);
     workspace.getExecs = async () => [[], ["util"], []];
     workspace.getPkgs = async () => ["tools"];
-    const rerunOf = (name: string) => rerunCommandOf([name], [undefined], 0);
-    await expect(
-      getInternalArgumentValue({ key: "", idx: 0, type: "Lib" }, undefined, workspace, rerunOf("remove-library")),
-    ).rejects.toThrow("so rerun it as `akan remove-library <lib>` (choices: util).");
-    await expect(
-      getInternalArgumentValue({ key: "", idx: 0, type: "Pkg" }, undefined, workspace, rerunOf("remove-package")),
-    ).rejects.toThrow("so rerun it as `akan remove-package <pkg>` (choices: tools).");
+    workspace.getDirInModule = async (basePath) => (basePath === "libs/util/lib" ? ["photo"] : []);
+    const lib = await getInternalArgumentValue({ key: "", idx: 0, type: "Lib" }, undefined, workspace);
+    expect(lib instanceof LibExecutor ? lib.name : null).toBe("util");
+    const pkg = await getInternalArgumentValue({ key: "", idx: 0, type: "Pkg" }, undefined, workspace);
+    expect(pkg instanceof PkgExecutor ? pkg.name : null).toBe("tools");
+    const mod = await getInternalArgumentValue({ key: "", idx: 0, type: "Module" }, undefined, workspace);
+    expect(mod instanceof ModuleExecutor ? `${mod.sys.name}:${mod.name}` : null).toBe("util:photo");
     expect(asked).toEqual([]);
+
+    setTTY(true);
+    answer = "util";
+    await getInternalArgumentValue({ key: "", idx: 0, type: "Lib" }, undefined, workspace);
+    expect(asked).toEqual([["util"]]);
   });
 
   test("without a terminal, a named target the workspace lacks is refused, not swapped for the only one", async () => {
@@ -608,6 +630,49 @@ describe("a Sys that defaults to the only app", () => {
     expect(taken instanceof AppExecutor ? taken.name : null).toBe("web");
     expect(asked).toEqual([]);
   });
+
+  test("a module an app or a lib lacks is refused with the modules there are, in a terminal too", async () => {
+    setTTY(true);
+    answer = "util";
+    const workspace = await moduleWorkspace();
+    for (const value of ["util:nope", "web:nope"]) {
+      const sysName = value.split(":")[0];
+      await expect(
+        getInternalArgumentValue(
+          { key: "", idx: 0, type: "Module" },
+          value,
+          workspace,
+          rerunCommandOf(["create-view", value], [value], 0),
+        ),
+      ).rejects.toThrow(
+        `Unknown module '${value}': ${sysName} has no such module, so rerun it as \`akan create-view <sys:module>\` (choices: web:card, util:photo).`,
+      );
+    }
+    expect(asked).toEqual([]);
+    const photo = await getInternalArgumentValue({ key: "", idx: 0, type: "Module" }, "util:photo", workspace);
+    expect(photo instanceof ModuleExecutor ? `${photo.sys.name}:${photo.name}` : null).toBe("util:photo");
+  });
+
+  test("a service module is taken by its exact name where the target opts in, as remove-module does", async () => {
+    setTTY(true);
+    const workspace = await moduleWorkspace();
+    const services = { key: "", idx: 0, type: "Module", option: { services: true } } as const;
+    const billing = await getInternalArgumentValue(services, "web:_billing", workspace, undefined, {
+      destructive: true,
+    });
+    expect(billing instanceof ModuleExecutor ? `${billing.sys.name}:${billing.name}` : null).toBe("web:_billing");
+    await expect(
+      getInternalArgumentValue(services, undefined, workspace, rerunCommandOf(["remove-module"], [undefined], 0), {
+        destructive: true,
+      }),
+    ).rejects.toThrow(
+      "so rerun it as `akan remove-module <sys:module>` (choices: web:card, web:_billing, util:photo).",
+    );
+    await expect(
+      getInternalArgumentValue({ key: "", idx: 0, type: "Module" }, "web:_billing", workspace),
+    ).rejects.toThrow("Unknown module 'web:_billing': web has no such module");
+    expect(asked).toEqual([]);
+  });
 });
 
 describe("the line a refused target is rerun with", () => {

package/frontendBuild/allRoutesBuilder.test.ts

@@ -32,14 +32,18 @@ const writeApp = async () => {
   );
   await write(
     path.join(appDir, "page/memo.tsx"),
-    'import { Memo } from "../ui/Memo";\nexport default function Page() {\n  return <Memo />;\n}\n',
+    'import { System } from "akanjs/ui/System";\nimport { Memo } from "../ui/Memo";\nexport default function Page() {\n  return <><Memo /><System.ThemeToggle /></>;\n}\n',
+  );
+  await write(
+    path.join(appDir, "page/shell.tsx"),
+    'import { CSR } from "akanjs/ui/System/CSR";\nexport default function Page() {\n  return <CSR />;\n}\n',
   );
   const app = {
     name: "demo",
     cwdPath: appDir,
     dist: { cwdPath: path.join(root, "dist/apps/demo") },
     workspace: { workspaceRoot: root },
-    getPageKeys: async () => ["./_index.tsx", "./memo.tsx"],
+    getPageKeys: async () => ["./_index.tsx", "./memo.tsx", "./shell.tsx"],
     getConfig: async () => ({ basePaths: [], optimizeImports: [], barrelImports: [] }),
     getTsConfig: async () => ({ compilerOptions: { paths } }),
     getPublicEnv: () => ({}),
@@ -51,12 +55,12 @@ const writeApp = async () => {
 };
 
 describe("AllRoutesBuilder", () => {
-  test("writes the route manifest, then the preload table once the runtime chunks are known, and each route's modules", async () => {
+  test("writes the route manifest, then the preload table once the runtime chunks are known, and each route's modules without System's CSR and MCP App providers unless the page imports one", async () => {
     const app = await writeApp();
     const routes = new AllRoutesBuilder(app as never, "build");
     const { manifest, manifestPath } = await routes.build();
 
-    expect(new Set(manifest.routeIds)).toEqual(new Set(["/:lang", "/:lang/memo"]));
+    expect(new Set(manifest.routeIds)).toEqual(new Set(["/:lang", "/:lang/memo", "/:lang/shell"]));
     expect(await Bun.file(manifestPath).json()).not.toHaveProperty("modulePreloads");
 
     const runtimeChunks = { runtime: ["/_akan/client/rsc.js"], vendors: { react: ["/_akan/client/react.js"] } };
@@ -70,8 +74,14 @@ describe("AllRoutesBuilder", () => {
     const [home] = chunksOf("apps/demo/ui/Home.tsx#Home");
     const [memo] = chunksOf("apps/demo/ui/Memo.tsx#Memo");
     const shell = chunksOf("akanjs/ui/System/Client.tsx#Client");
+    const [csrShell] = chunksOf("akanjs/ui/System/CSR.tsx#CSR");
+    const [mcpAppShell] = chunksOf("akanjs/ui/System/App.tsx#AppProvider");
+    const [themeToggle] = chunksOf("akanjs/ui/System/ThemeToggle.tsx#ThemeToggle");
     const modules = preloads.modulesByRoute();
     expect(shell.length).toBeGreaterThan(0);
+    expect([csrShell, mcpAppShell, themeToggle]).not.toContain(undefined);
+    expect(modules["/:lang/memo"]).toContain(themeToggle);
+    expect(modules["/:lang/shell"]).toContain(csrShell);
     for (const [routeId, own, other] of [
       ["/:lang", home, memo],
       ["/:lang/memo", memo, home],
@@ -79,6 +89,8 @@ describe("AllRoutesBuilder", () => {
       expect(modules[routeId]?.slice(0, 2)).toEqual(["/_akan/client/rsc.js", "/_akan/client/react.js"]);
       expect(modules[routeId]).toEqual(expect.arrayContaining([own, ...shell]));
       expect(modules[routeId]).not.toContain(other);
+      expect(modules[routeId]).not.toContain(csrShell);
+      expect(modules[routeId]).not.toContain(mcpAppShell);
     }
   }, 30_000);
 });

package/frontendBuild/allRoutesBuilder.ts

@@ -1,6 +1,11 @@
 import path from "node:path";
 import type { RoutesManifest } from "akanjs/server";
-import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
+import {
+  isImplicitRootLayoutKey,
+  type PageEntry,
+  ROOT_LAYOUT_SYSTEM,
+  resolveSsrPageEntriesForApp,
+} from "../artifact/implicitRootLayout";
 import { computeRouteSeedIndex, type RouteSeedIndex } from "../artifact/routeSeedIndex";
 import type { App } from "../commandDecorators";
 import type { ClientEntryDiscovery } from "./clientBuildTypes";
@@ -26,7 +31,7 @@ export class AllRoutesBuilder {
   };
   #knownSet = new Set<string>();
   #routeIds: string[] = [];
-  #entriesByRoute = new Map<string, string[]>();
+  #ssrEntriesByRoute = new Map<string, string[]>();
   #externalsByChunkUrl: Record<string, string[]> = {};
   #discovery: ClientEntryDiscovery | null = null;
 
@@ -41,15 +46,17 @@ export class AllRoutesBuilder {
     const pageEntries = await resolveSsrPageEntriesForApp(this.#app, pageKeys);
     const seedIndex = computeRouteSeedIndex(pageEntries);
     this.#app.verbose(`[build-all] discovered ${seedIndex.entries.length} routes`);
-    this.#discovery = await GraphClientEntryDiscovery.create(this.#app);
+    const discovery = await GraphClientEntryDiscovery.create(this.#app);
+    this.#discovery = discovery;
+    const importsAs = await this.#ssrImportsAs(discovery, pageEntries);
 
     // Every route's entries go into one Bun.build: chunk splitting only dedupes within a single build.
     const allEntries = new Set<string>();
     for (const entry of seedIndex.entries) {
       const seeds = Array.from(new Set([...seedIndex.globalLayoutFiles, ...entry.seeds]));
-      const routeEntries = await this.#discovery.discover(seeds);
+      const routeEntries = await discovery.discover(seeds);
       for (const discovered of routeEntries) allEntries.add(discovered);
-      this.#entriesByRoute.set(entry.routeId, routeEntries);
+      this.#ssrEntriesByRoute.set(entry.routeId, await discovery.discover(seeds, { importsAs }));
       this.#routeIds.push(entry.routeId);
     }
     this.#app.verbose(`[build-all] ${allEntries.size} client entries across ${this.#routeIds.length} routes`);
@@ -71,10 +78,21 @@ export class AllRoutesBuilder {
     return { manifest, manifestPath, seedIndex };
   }
 
+  async #ssrImportsAs(discovery: GraphClientEntryDiscovery, pageEntries: PageEntry[]) {
+    const { specifier, ssrShell, importsNoSsrPageRenders } = ROOT_LAYOUT_SYSTEM;
+    const importsAs = new Map<string, ReadonlyMap<string, string | null>>();
+    const toShell = new Map([[specifier, ssrShell]]);
+    for (const { key, moduleAbsPath } of pageEntries)
+      if (isImplicitRootLayoutKey(key)) importsAs.set(path.resolve(moduleAbsPath), toShell);
+    const system = await discovery.resolveImport(specifier, this.#app.cwdPath);
+    if (system) importsAs.set(system, new Map(importsNoSsrPageRenders.map((spec) => [spec, null])));
+    return importsAs;
+  }
+
   async writeModulePreloads(runtimeChunks: RuntimeChunks): Promise<RouteModulePreloads> {
     const preloads = new RouteModulePreloads({
       runtimeChunks,
-      entriesByRoute: this.#entriesByRoute,
+      entriesByRoute: this.#ssrEntriesByRoute,
       clientManifest: this.#merged.clientManifest,
       externalsByChunkUrl: this.#externalsByChunkUrl,
       workspaceRoot: this.#app.workspace.workspaceRoot,

package/frontendBuild/bundleDefine.ts

@@ -9,6 +9,8 @@ export const bundleDefine = (app: App, command: "build" | "start", renderEnv: "s
   return {
     "process.env.NODE_ENV": JSON.stringify(nodeEnv),
     "process.env.AKAN_PUBLIC_RENDER_ENV": JSON.stringify(renderEnv),
+    //? NODE_ENV is production under `NODE_ENV=production akan start` too; this says the page's vendors were narrowed.
+    "process.env.AKAN_BUNDLE_COMMAND": JSON.stringify(command),
     //? Sorted: Windows hands a child its environment sorted, while keys the config sets at runtime trail the parent's,
     //? and the dev registries hash this object to tell a worker's build from the builder's.
     ...Object.fromEntries(

package/frontendBuild/clientBuildTypes.ts

@@ -38,8 +38,12 @@ export const CLIENT_BUNDLE_NAMING = {
   asset: "assets/[hash].[ext]",
 } as const;
 
+export interface DiscoverOptions {
+  importsAs?: ReadonlyMap<string, ReadonlyMap<string, string | null>>;
+}
+
 export interface ClientEntryDiscovery {
-  discover(seeds: string[]): Promise<string[]>;
+  discover(seeds: string[], options?: DiscoverOptions): Promise<string[]>;
   invalidate?(files: string[]): void;
 }
 
@@ -59,7 +63,6 @@ export interface BundleClientEntriesInternalOptions extends BundleClientEntriesO
   externalSubpaths?: readonly string[];
   externalAliases?: Partial<Record<string, string>>;
   command?: "build" | "start";
-  /** Per absolute entry, the only names its alias re-exports, in place of every name the entry declares. */
   entryExports?: Partial<Record<string, readonly string[]>>;
 }
 

package/frontendBuild/clientEntryDiscovery.test.ts

@@ -161,4 +161,32 @@ describe("GraphClientEntryDiscovery", () => {
     expect(await discovery.discover([file("A.tsx")])).toEqual([file("C.tsx")]);
     expect(await discovery.discover([file("B.tsx")])).toEqual([file("C.tsx")]);
   });
+
+  test("a file walked with its imports swapped or dropped keeps that walk's answer out of every other walk", async () => {
+    const file = await tempDir();
+    await Bun.write(file("Layout.tsx"), 'import "./Both";\n');
+    await Bun.write(file("Page.tsx"), 'import "./Layout";\n');
+    await Bun.write(file("Both.tsx"), 'import "./Server";\nimport "./Browser";\n');
+    await Bun.write(file("Server.tsx"), 'import "./S";\n');
+    await Bun.write(file("Browser.tsx"), '"use client";\nexport const Browser = () => null;\n');
+    await Bun.write(file("S.tsx"), '"use client";\nexport const S = () => null;\n');
+    const discovery = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+    const importsAs = new Map([[file("Layout.tsx"), new Map([["./Both", "./Server"]])]]);
+
+    expect(await discovery.discover([file("Page.tsx")])).toEqual([file("Browser.tsx"), file("S.tsx")]);
+    expect(await discovery.discover([file("Page.tsx")], { importsAs })).toEqual([file("S.tsx")]);
+    expect(await discovery.discover([file("Layout.tsx")], { importsAs })).toEqual([file("S.tsx")]);
+    expect(await discovery.discover([file("Page.tsx")])).toEqual([file("Browser.tsx"), file("S.tsx")]);
+    const dropped = new Map([[file("Both.tsx"), new Map([["./Browser", null]])]]);
+    expect(await discovery.discover([file("Page.tsx")], { importsAs: dropped })).toEqual([file("S.tsx")]);
+
+    const fresh = new GraphClientEntryDiscovery({ barrelImports: [] }, (async () => null) as never);
+    expect(await fresh.discover([file("Page.tsx")], { importsAs })).toEqual([file("S.tsx")]);
+    expect(await fresh.discover([file("Page.tsx")])).toEqual([file("Browser.tsx"), file("S.tsx")]);
+    expect(await fresh.discover([file("Layout.tsx")])).toEqual([file("Browser.tsx"), file("S.tsx")]);
+
+    await Bun.write(file("Server.tsx"), "export const server = 1;\n");
+    fresh.invalidate([file("Server.tsx")]);
+    expect(await fresh.discover([file("Page.tsx")], { importsAs })).toEqual([]);
+  });
 });

package/frontendBuild/clientEntryDiscovery.ts

@@ -4,7 +4,7 @@ import { SOURCE_EXTS } from "../akanApp/devHostPolicy";
 import type { App } from "../commandDecorators";
 import { BarrelAnalyzer, type BarrelExportMap } from "../transforms/barrelAnalyzer";
 import { createTsconfigPackageResolver, rewriteBarrelImports } from "../transforms/barrelImportsPlugin";
-import type { AkanConfig, ClientEntryDiscovery, ScannedImport } from "./clientBuildTypes";
+import type { AkanConfig, ClientEntryDiscovery, DiscoverOptions, ScannedImport } from "./clientBuildTypes";
 
 const USE_CLIENT_RE = /^\s*(?:\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
 const NODE_MODULES_RE = /[\\/]node_modules[\\/]/;
@@ -31,6 +31,8 @@ interface DiscoveryWalk {
   //? Every file's result within this walk, partial ones included: the file the cycle went back to is an ancestor here
   //? and brings the rest itself, and re-walking each path through a dense cycle grows exponentially.
   memo: Map<string, Set<string>>;
+  importsAs?: DiscoverOptions["importsAs"];
+  reachable: Map<string, Set<string>>;
 }
 
 const exportsKeyOf = (map: BarrelExportMap | null): string =>
@@ -50,6 +52,8 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   #resolvedFileCache = new Map<string, Lookup<string | null>>();
   #resolvedSpecifierCache = new Map<string, Lookup<string | null>>();
   #reachableEntriesCache = new Map<string, Set<string>>();
+  //? Keyed by a walk's `importsAs`: a file's answer under swapped imports holds only for walks swapping the same ones.
+  #swappedEntriesCaches = new WeakMap<object, Map<string, Set<string>>>();
   #readFiles = new Set<string>();
   #barrelImporters = new Map<string, Set<string>>();
   //? Barrels a save went beside, by the analysis before it: a save of any component re-reads its barrel, and only an
@@ -70,17 +74,29 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
     return new GraphClientEntryDiscovery(await app.getConfig(), await createTsconfigPackageResolver(app));
   }
 
-  async discover(seeds: string[]): Promise<string[]> {
+  async discover(seeds: string[], { importsAs }: DiscoverOptions = {}): Promise<string[]> {
     this.#settled = this.#settled.then(() => this.#dropRenarrowed());
     await this.#settled;
     const entries = new Set<string>();
+    const reachable = importsAs ? this.#swappedEntriesCache(importsAs) : this.#reachableEntriesCache;
     for (const seed of seeds) {
-      const walk: DiscoveryWalk = { visiting: new Set(), partial: new Set(), memo: new Map() };
+      const walk: DiscoveryWalk = { visiting: new Set(), partial: new Set(), memo: new Map(), importsAs, reachable };
       for (const entry of await this.#discoverFromFile(seed, walk)) entries.add(entry);
     }
     return Array.from(entries).sort();
   }
 
+  async resolveImport(spec: string, importerDir: string): Promise<string | null> {
+    const resolved = await this.#resolveSpecifier(spec, importerDir);
+    return resolved ? path.resolve(resolved) : null;
+  }
+
+  #swappedEntriesCache(importsAs: object): Map<string, Set<string>> {
+    const cache = this.#swappedEntriesCaches.get(importsAs) ?? new Map<string, Set<string>>();
+    this.#swappedEntriesCaches.set(importsAs, cache);
+    return cache;
+  }
+
   invalidate(files: string[]): void {
     if (files.length === 0) return;
     let moved = false;
@@ -95,6 +111,7 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
     this.#epoch += 1;
     // Reachable-entry results are transitive, so a changed child invalidates every ancestor.
     this.#reachableEntriesCache.clear();
+    this.#swappedEntriesCaches = new WeakMap();
     for (const [barrel, before] of this.#analyzer.forget(files))
       if (!this.#reread.has(barrel)) this.#reread.set(barrel, before);
     //? A file gone, or one never read, can leave a found resolution on its old target (`Chart.tsx` to
@@ -223,7 +240,8 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   async #discoverFromFile(file: string, walk: DiscoveryWalk): Promise<Set<string>> {
     const epoch = this.#epoch;
     const absPath = path.resolve(file);
-    const cached = this.#reachableEntriesCache.get(absPath);
+    const importsAs = walk.importsAs?.get(absPath);
+    const cached = walk.reachable.get(absPath);
     if (cached) return new Set(cached);
     const memo = walk.memo.get(absPath);
     if (memo) {
@@ -253,7 +271,8 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
 
     const importerDir = path.dirname(absPath);
     for (const imp of facts.imports) {
-      const spec = imp.path;
+      const swapped = importsAs?.get(imp.path);
+      const spec = swapped === undefined ? imp.path : swapped;
       if (!spec) continue;
       if (NON_SOURCE_EXT_RE.test(spec)) continue;
       const resolved = await this.#resolveSpecifier(spec, importerDir);
@@ -268,7 +287,7 @@ export class GraphClientEntryDiscovery implements ClientEntryDiscovery {
   #finishDiscovery(absPath: string, walk: DiscoveryWalk, entries: Set<string>, epoch: number): Set<string> {
     walk.visiting.delete(absPath);
     walk.memo.set(absPath, entries);
-    if (epoch === this.#epoch && !walk.partial.has(absPath)) this.#reachableEntriesCache.set(absPath, entries);
+    if (epoch === this.#epoch && !walk.partial.has(absPath)) walk.reachable.set(absPath, entries);
     return new Set(entries);
   }
 }