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

package/apiReport/apiTargets.ts

@@ -0,0 +1,311 @@
+import ts from "typescript";
+import { ApiDeclarationPrinter } from "./apiDeclarationPrinter";
+
+export interface ApiTarget {
+  id: string;
+  name: string;
+  origin: string;
+  file: ts.SourceFile | null;
+  statements: ts.Statement[];
+  thirdParty: string | null;
+  members: ts.Symbol[] | null;
+}
+
+interface ImportBinding {
+  specifier: string;
+  imported: string;
+}
+
+//* Statements come from the emitted `.d.ts`, which also holds what the emit adds, such as a mixin class's `X_base`.
+export class ApiTargets {
+  readonly #program: ts.Program;
+  readonly #checker: ts.TypeChecker;
+  readonly #emitted: ReadonlyMap<string, string>;
+  readonly #parsed = new Map<string, ts.SourceFile>();
+  readonly #indexes = new Map<ts.SourceFile, Map<string, ts.Statement[]>>();
+  readonly #imports = new Map<ts.SourceFile, Map<string, ImportBinding>>();
+  readonly #modules = new Map<string, ts.SourceFile | null>();
+  readonly #moduleExports = new Map<ts.SourceFile, Map<string, ts.Symbol>>();
+  readonly #references = new Map<string, ApiTarget[]>();
+
+  constructor(program: ts.Program, emitted: ReadonlyMap<string, string>) {
+    this.#program = program;
+    this.#checker = program.getTypeChecker();
+    this.#emitted = emitted;
+  }
+
+  exportsOf(sourceFile: ts.SourceFile) {
+    const moduleSymbol = this.#checker.getSymbolAtLocation(sourceFile);
+    return moduleSymbol ? this.#checker.getExportsOfModule(moduleSymbol) : [];
+  }
+
+  typeTextOf(symbol: ts.Symbol) {
+    const target = symbol.flags & ts.SymbolFlags.Alias ? this.#checker.getAliasedSymbol(symbol) : symbol;
+    return this.#checker.typeToString(
+      this.#checker.getTypeOfSymbol(target),
+      undefined,
+      ts.TypeFormatFlags.NoTruncation,
+    );
+  }
+
+  ofSymbol(symbol: ts.Symbol): ApiTarget[] {
+    const target = symbol.flags & ts.SymbolFlags.Alias ? this.#checker.getAliasedSymbol(symbol) : symbol;
+    const targets = new Map<string, ApiTarget>();
+    for (const declaration of target.declarations ?? []) {
+      const resolved = this.#ofDeclaration(declaration);
+      if (resolved && !targets.has(resolved.id)) targets.set(resolved.id, resolved);
+    }
+    return [...targets.values()];
+  }
+
+  expand(targets: ApiTarget[], seen = new Set<string>()): ApiTarget[] {
+    return targets.flatMap((target) => {
+      if (!target.members) return [target];
+      if (seen.has(target.id)) return [];
+      seen.add(target.id);
+      return this.expand(
+        target.members.flatMap((member) => this.ofSymbol(member)),
+        seen,
+      );
+    });
+  }
+
+  referencesOf(target: ApiTarget): ApiTarget[] {
+    const cached = this.#references.get(target.id);
+    if (cached) return cached;
+    const file = target.file;
+    const found = file
+      ? target.statements.flatMap((statement) =>
+          this.#referencesIn(ApiDeclarationPrinter.prepared(statement), file, target.origin),
+        )
+      : [];
+    const references = this.expand(found);
+    this.#references.set(target.id, references);
+    return references;
+  }
+
+  #ofDeclaration(declaration: ts.Declaration): ApiTarget | null {
+    if (ts.isSourceFile(declaration)) {
+      return {
+        id: `${declaration.fileName}\0*`,
+        name: "*",
+        origin: declaration.fileName,
+        file: null,
+        statements: [],
+        thirdParty: ApiTargets.packageOf(declaration.fileName),
+        members: this.exportsOf(declaration),
+      };
+    }
+    const sourceFile = declaration.getSourceFile();
+    const name = ApiTargets.localNameOf(declaration);
+    if (name === null) return null;
+    const thirdParty = ApiTargets.packageOf(sourceFile.fileName);
+    const base = { id: `${sourceFile.fileName}\0${name}`, name, origin: sourceFile.fileName, members: null };
+    if (thirdParty) return { ...base, file: null, statements: [], thirdParty };
+    const file = sourceFile.isDeclarationFile ? sourceFile : this.#declarationFileOf(sourceFile);
+    if (!file) return { ...base, file: null, statements: [], thirdParty: null };
+    const statements = this.#indexOf(file).get(name);
+    if (statements) return { ...base, file, statements, thirdParty: null };
+    const nested = ApiTargets.#statementOf(declaration);
+    return {
+      ...base,
+      id: `${base.id}\0${declaration.pos}`,
+      file,
+      statements: nested && sourceFile.isDeclarationFile ? [nested] : [],
+      thirdParty: null,
+    };
+  }
+
+  #referencesIn(root: ts.Node, file: ts.SourceFile, origin: string): ApiTarget[] {
+    const found: ApiTarget[] = [];
+    const visit = (node: ts.Node) => {
+      if (ts.isTypeReferenceNode(node))
+        found.push(...this.#resolve(ApiTargets.#segmentsOf(node.typeName), node, file, origin));
+      else if (ts.isExpressionWithTypeArguments(node))
+        found.push(...this.#resolve(ApiTargets.#segmentsOf(node.expression), node, file, origin));
+      else if (ts.isTypeQueryNode(node))
+        found.push(...this.#resolve(ApiTargets.#segmentsOf(node.exprName), node, file, origin));
+      else if (ts.isComputedPropertyName(node))
+        found.push(...this.#resolve(ApiTargets.#segmentsOf(node.expression), node, file, origin));
+      else if (ts.isImportTypeNode(node)) found.push(...this.#resolveImportType(node, origin));
+      ts.forEachChild(node, visit);
+    };
+    visit(root);
+    return found;
+  }
+
+  #resolve(segments: string[] | null, at: ts.Node, file: ts.SourceFile, origin: string): ApiTarget[] {
+    const [head, next] = segments ?? [];
+    if (!head || ApiTargets.#isTypeParameter(at, head)) return [];
+    const local = this.#indexOf(file).get(head);
+    if (local) return [this.#local(file, origin, head, local)];
+    const binding = this.#importsOf(file).get(head);
+    if (!binding) return [];
+    const module = this.#moduleOf(binding.specifier, origin);
+    if (!module) return [];
+    if (binding.imported !== "*") return this.#exported(module, binding.imported);
+    return next ? this.#exported(module, next) : this.#namespaceOf(module);
+  }
+
+  #resolveImportType(node: ts.ImportTypeNode, origin: string): ApiTarget[] {
+    const argument = node.argument;
+    if (!ts.isLiteralTypeNode(argument) || !ts.isStringLiteral(argument.literal)) return [];
+    const module = this.#moduleOf(argument.literal.text, origin);
+    if (!module) return [];
+    const [name] = node.qualifier ? (ApiTargets.#segmentsOf(node.qualifier) ?? []) : [];
+    return name ? this.#exported(module, name) : this.#namespaceOf(module);
+  }
+
+  #local(file: ts.SourceFile, origin: string, name: string, statements: ts.Statement[]): ApiTarget {
+    return { id: `${origin}\0${name}`, name, origin, file, statements, thirdParty: null, members: null };
+  }
+
+  #exported(module: ts.SourceFile, name: string) {
+    const symbol = this.#moduleExportsOf(module).get(name);
+    return symbol ? this.ofSymbol(symbol) : [];
+  }
+
+  #namespaceOf(module: ts.SourceFile): ApiTarget[] {
+    return [
+      {
+        id: `${module.fileName}\0*`,
+        name: "*",
+        origin: module.fileName,
+        file: null,
+        statements: [],
+        thirdParty: null,
+        members: [...this.#moduleExportsOf(module).values()],
+      },
+    ];
+  }
+
+  #moduleExportsOf(module: ts.SourceFile) {
+    const cached = this.#moduleExports.get(module);
+    if (cached) return cached;
+    const exports = new Map(this.exportsOf(module).map((symbol) => [symbol.getName(), symbol]));
+    this.#moduleExports.set(module, exports);
+    return exports;
+  }
+
+  #moduleOf(specifier: string, origin: string) {
+    const key = `${origin}\0${specifier}`;
+    if (this.#modules.has(key)) return this.#modules.get(key) ?? null;
+    const resolved = ts.resolveModuleName(specifier, origin, this.#program.getCompilerOptions(), ts.sys).resolvedModule;
+    const fileName = resolved?.resolvedFileName;
+    const module = fileName && !ApiTargets.packageOf(fileName) ? (this.#program.getSourceFile(fileName) ?? null) : null;
+    this.#modules.set(key, module);
+    return module;
+  }
+
+  #declarationFileOf(sourceFile: ts.SourceFile) {
+    const cached = this.#parsed.get(sourceFile.fileName);
+    if (cached) return cached;
+    const text = this.#emitted.get(sourceFile.fileName);
+    if (text === undefined) return null;
+    const fileName = sourceFile.fileName.replace(/\.tsx?$/, ".d.ts");
+    const parsed = ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+    this.#parsed.set(sourceFile.fileName, parsed);
+    return parsed;
+  }
+
+  #indexOf(file: ts.SourceFile) {
+    const cached = this.#indexes.get(file);
+    if (cached) return cached;
+    const index = new Map<string, ts.Statement[]>();
+    const add = (name: string, statement: ts.Statement) => index.set(name, [...(index.get(name) ?? []), statement]);
+    for (const statement of file.statements) {
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations)
+          if (ts.isIdentifier(declaration.name))
+            add(declaration.name.text, ApiTargets.#narrowed(statement, declaration));
+        continue;
+      }
+      const name = ApiDeclarationPrinter.isNamed(statement) ? ApiTargets.localNameOf(statement) : null;
+      if (name !== null) add(name, statement);
+    }
+    this.#indexes.set(file, index);
+    return index;
+  }
+
+  #importsOf(file: ts.SourceFile) {
+    const cached = this.#imports.get(file);
+    if (cached) return cached;
+    const bindings = new Map<string, ImportBinding>();
+    for (const statement of file.statements) {
+      if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+      const specifier = statement.moduleSpecifier.text;
+      const clause = statement.importClause;
+      if (clause?.name) bindings.set(clause.name.text, { specifier, imported: "default" });
+      const named = clause?.namedBindings;
+      if (named && ts.isNamespaceImport(named)) bindings.set(named.name.text, { specifier, imported: "*" });
+      if (named && ts.isNamedImports(named))
+        for (const element of named.elements)
+          bindings.set(element.name.text, { specifier, imported: (element.propertyName ?? element.name).text });
+    }
+    this.#imports.set(file, bindings);
+    return bindings;
+  }
+
+  static localNameOf(declaration: ts.Declaration): string | null {
+    const name = ts.getNameOfDeclaration(declaration);
+    if (name && ts.isIdentifier(name)) return name.text;
+    if (name) return null;
+    const modifiers = ts.canHaveModifiers(declaration) ? ts.getModifiers(declaration) : undefined;
+    return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ? "default" : null;
+  }
+
+  static packageOf(fileName: string) {
+    const normalized = fileName.replaceAll("\\", "/");
+    const idx = normalized.lastIndexOf("/node_modules/");
+    if (idx < 0) return null;
+    const [scope = "", name = ""] = normalized.slice(idx + "/node_modules/".length).split("/");
+    return scope.startsWith("@") ? `${scope}/${name}` : scope;
+  }
+
+  static #statementOf(declaration: ts.Declaration): ts.Statement | null {
+    if (ts.isVariableDeclaration(declaration)) {
+      const statement = declaration.parent.parent;
+      return ts.isVariableStatement(statement) ? ApiTargets.#narrowed(statement, declaration) : null;
+    }
+    return ApiDeclarationPrinter.isNamed(declaration) ? declaration : null;
+  }
+
+  static #narrowed(statement: ts.VariableStatement, declaration: ts.VariableDeclaration) {
+    if (statement.declarationList.declarations.length === 1) return statement;
+    const narrowed = ts.factory.updateVariableStatement(
+      statement,
+      statement.modifiers,
+      ts.factory.updateVariableDeclarationList(statement.declarationList, [declaration]),
+    );
+    ts.setOriginalNode(narrowed, statement);
+    return narrowed;
+  }
+
+  static #segmentsOf(node: ts.Node): string[] | null {
+    if (ts.isIdentifier(node)) return [node.text];
+    if (ts.isQualifiedName(node)) {
+      const left = ApiTargets.#segmentsOf(node.left);
+      return left && [...left, node.right.text];
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+      const left = ApiTargets.#segmentsOf(node.expression);
+      return left && [...left, node.name.text];
+    }
+    return null;
+  }
+
+  static #isTypeParameter(at: ts.Node, name: string) {
+    for (let node = at.parent; node && !ts.isSourceFile(node); node = node.parent) {
+      const typeParameters = (node as { typeParameters?: ts.NodeArray<ts.TypeParameterDeclaration> }).typeParameters;
+      if (typeParameters?.some((parameter) => parameter.name.text === name)) return true;
+      if (ts.isMappedTypeNode(node) && node.typeParameter.name.text === name) return true;
+      if (ts.isConditionalTypeNode(node) && ApiTargets.#infers(node.extendsType, name)) return true;
+    }
+    return false;
+  }
+
+  static #infers(node: ts.Node, name: string): boolean {
+    if (ts.isInferTypeNode(node) && node.typeParameter.name.text === name) return true;
+    return ts.forEachChild(node, (child) => ApiTargets.#infers(child, name) || undefined) ?? false;
+  }
+}

package/apiReport/changesetBump.ts

@@ -0,0 +1,19 @@
+export type Bump = "major" | "minor" | "patch";
+
+export class ChangesetBump {
+  static readonly #rank: Record<Bump, number> = { patch: 0, minor: 1, major: 2 };
+  static readonly #entry = /^\s*(["']?)([^"'#:\s][^"'#:]*?)\1\s*:\s*(["']?)(major|minor|patch)\3\s*(?:#.*)?$/;
+
+  static of(text: string, packageName: string): Bump | null {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text.replace(/^/, ""))?.[1] ?? "";
+    for (const line of frontmatter.split(/\r?\n/)) {
+      const match = ChangesetBump.#entry.exec(line);
+      if (match?.[2] === packageName) return match[4] as Bump;
+    }
+    return null;
+  }
+
+  static atLeast(bump: Bump | null, floor: Bump) {
+    return bump !== null && ChangesetBump.#rank[bump] >= ChangesetBump.#rank[floor];
+  }
+}

package/applicationBuildReporter.test.ts

@@ -51,4 +51,25 @@ describe("ApplicationBuildReporter.printSummary", () => {
       lines.indexOf("Route artifacts: dist/apps/shop/.akan/artifact"),
     );
   });
+
+  test("prints only the route JS budget warnings for a quiet build", () => {
+    const routeJsWarnings = [{ file: "apps/shop/akan.budget.json", message: "unreadable", fix: "correct it" }];
+    ApplicationBuildReporter.printRouteJsWarnings({ routeJsWarnings });
+    ApplicationBuildReporter.printRouteJsWarnings({});
+
+    expect(rawLog.mock.calls.map(([line]) => line)).toEqual([
+      "Warning: apps/shop/akan.budget.json: unreadable (correct it)",
+    ]);
+  });
+
+  test("prints each route JS budget warning of a build that only reports it", () => {
+    const routeJsWarnings = [
+      { file: "apps/shop/akan.budget.json", message: "/:lang/memo loads 133,120 bytes brotli", fix: "shrink it" },
+    ];
+    ApplicationBuildReporter.printSummary({ ...resultFor("main"), routeJsWarnings });
+
+    expect(rawLog.mock.calls.map(([line]) => line)).toContain(
+      "Warning: apps/shop/akan.budget.json: /:lang/memo loads 133,120 bytes brotli (shrink it)",
+    );
+  });
 });

package/applicationBuildReporter.ts

@@ -40,12 +40,20 @@ export class ApplicationBuildReporter {
       for (const line of RouteJsBudget.formatTable(result.routeJs)) Logger.rawLog(line);
       Logger.rawLog("");
     }
+    if (result.routeJsWarnings?.length) {
+      ApplicationBuildReporter.printRouteJsWarnings(result);
+      Logger.rawLog("");
+    }
     Logger.rawLog(`Route artifacts: ${result.artifactDir}`);
     Logger.rawLog(`Server output: ${result.outputDir}`);
     Logger.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
     if (result.environment === "local") Logger.rawLog(ApplicationBuildReporter.localBuildNotice);
   }
 
+  static printRouteJsWarnings({ routeJsWarnings = [] }: Pick<ApplicationBuildResult, "routeJsWarnings">) {
+    for (const { file, message, fix } of routeJsWarnings) Logger.rawLog(`Warning: ${file}: ${message} (${fix})`);
+  }
+
   static readonly localBuildNotice =
     "Built for local: the server runs without endpoint rate limits, and boots on local defaults (Redis on localhost, the first database mode) where a deployment would stop to ask. For a host others can reach, run `akan build <app> --env main` with AKAN_PUBLIC_REPO_NAME and AKAN_PUBLIC_SERVE_DOMAIN set in the shell or the workspace .env.";
 

package/applicationBuildRunner.ts

@@ -55,7 +55,10 @@ export interface ApplicationBuildRunnerOptions {
   environment?: string;
   /** Bundles `env/env.server.<environment>.<profile>.ts`, which may hold no secret, in place of the environment's file. */
   profile?: string;
-  /** `update` writes akan.budget.json, then enforces it; `report` names an overage without failing the build. */
+  /**
+   * `enforce` fails on an overage, a route with no entry, or a missing or unreadable akan.budget.json; `update` and
+   * `raise` rewrite the file first; `report` only warns.
+   */
   budget?: RouteJsBudgetMode;
 }
 export interface BuildOptions {
@@ -457,6 +460,7 @@ void run().catch((error) => {
     const budgetPath = path.join(this.#app.cwdPath, RouteJsBudget.fileName);
     const { summary: status, warnings } = await RouteJsBudget.check(sizes, {
       mode: this.#budget,
+      app: this.#app.name,
       budgetPath,
       source: path.relative(this.#app.workspace.workspaceRoot, budgetPath),
       environment,

package/artifact/implicitRootLayout.ts

@@ -71,10 +71,21 @@ export function getRootBoundarySegments(key: string): string[] | null {
   return prefix.split("/").filter(Boolean);
 }
 
+//? The generated root layout serves SSR, CSR and MCP App views alike; an SSR page renders only System's SSR shell.
+export const ROOT_LAYOUT_SYSTEM = {
+  specifier: "akanjs/ui/System/index.tsx",
+  ssrShell: "akanjs/ui/System/SSR.tsx",
+  importsNoSsrPageRenders: ["./CSR", "./App"],
+} as const;
+
 function implicitRootLayoutKey(segments: string[]): string {
   return `./${[...segments, "__root_layout"].join("/")}.tsx`;
 }
 
+export function isImplicitRootLayoutKey(key: string): boolean {
+  return key.endsWith("/__root_layout.tsx");
+}
+
 function implicitRootLayoutAbsPath(appCwdPath: string, segments: string[]): string {
   const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
   return path.join(path.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
@@ -218,7 +229,7 @@ ${layoutBinding}  return `;
     ? `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
 import { assertGuardOnChain, loadFonts, RouteGuards, resolveRouteModule, RouteHead } from "akanjs/client";
 import type { ReactNode } from "react";
-import { System } from "akanjs/ui/System/index.tsx";
+import { System } from "${ROOT_LAYOUT_SYSTEM.specifier}";
 import type { McpAppRootProps } from "akanjs/webkit";
 import { env } from "@apps/${opts.appName}/env/env.client";
 import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};

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/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;
 }
 

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([]);
+  });
 });