@akanjs/devkit 3.1.2-rc.4 → 3.2.0-rc.1

package/executors.ts

@@ -156,7 +156,7 @@ const parseEnvValue = (value: string) => {
   return inner.replace(/\\(.)/g, (pair, char: string) => (char === "n" ? "\n" : char === "r" ? "\r" : pair));
 };
 
-const parseEnvFile = (envPath: string): Record<string, string> => {
+export const parseEnvFile = (envPath: string): Record<string, string> => {
   const env: Record<string, string> = {};
   const content = (() => {
     try {
@@ -683,13 +683,15 @@ export class WorkspaceExecutor extends Executor {
   } = {}) {
     return new WorkspaceExecutor({ workspaceRoot, repoName });
   }
-  /** The public env a native build was told to reproduce (`--public-env`): it outranks `.env`, which outranks the rest. */
+  /** The public env a native build was told to reproduce (`--public-env`): it outranks the shell, which outranks `.env`. */
   static publicEnvPin: Record<string, string> | null = null;
   static readonly localServeDomain = "localhost";
   static getBaseDevEnv(envPath?: string) {
     // Bun auto-loads .env, so we use process.env directly
     const sourceEnv = {
-      ...(envPath ? { ...process.env, ...parseEnvFile(envPath) } : process.env),
+      ...(envPath ? parseEnvFile(envPath) : {}),
+      //? An empty export reads as unset, unlike in dotenv, so it can't blank a key the .env sets.
+      ...Object.fromEntries(Object.entries(process.env).filter(([, value]) => value)),
       ...WorkspaceExecutor.publicEnvPin,
     };
 

package/frameworkGraph.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { FrameworkGraph } from "./frameworkGraph";
+
+const workspaceRoot = path.resolve(import.meta.dir, "../../..");
+//? The other end of these lies outside the source read here: @akanjs/native's desktop shell answers file and secret
+//? requests, AkanApp's child reports a boot error from a code string, and the browser tab sends `sync-navigation` and
+//? handles every HmrMessage in a script string. `ws.*` and HMR `ok` have no site.
+const unrecognised = [
+  "AkanIpcMessage ws.opened sender",
+  "AkanIpcMessage ws.opened handler",
+  "AkanIpcMessage ws.closed sender",
+  "AkanIpcMessage ws.closed handler",
+  "AkanIpcMessage file.resolve handler",
+  "AkanIpcMessage file.resolved sender",
+  "AkanIpcMessage secret.request handler",
+  "AkanIpcMessage secret.answer sender",
+  "AkanIpcMessage error sender",
+  "HmrMessage sync-navigation sender",
+  "HmrMessage ok sender",
+];
+const handledInBrowser = new Set(["HmrMessage"]);
+
+const withWorkspace = async (files: Record<string, string>, run: (root: string) => Promise<void>) => {
+  const root = await mkdtemp(path.join(tmpdir(), "akan-framework-"));
+  try {
+    for (const [file, text] of Object.entries(files)) {
+      await mkdir(path.dirname(path.join(root, file)), { recursive: true });
+      await writeFile(path.join(root, file), text);
+    }
+    await run(root);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+};
+
+const installed = (version: string) => ({
+  "node_modules/akanjs/package.json": JSON.stringify({
+    name: "akanjs",
+    version,
+    exports: { ".": "./index.ts", "./package.json": "./package.json" },
+  }),
+  "node_modules/akanjs/index.ts": `export * from "./base";\n`,
+  "node_modules/akanjs/base/scalar.ts": "export class Scalar {}\n",
+  "node_modules/akanjs/native/bridge.ts": `import { Native } from "../vendor/@akanjs/native/index";\nexport class Bridge {}\n`,
+  "node_modules/akanjs/vendor/@akanjs/native/index.ts": "export class Native {}\n",
+  "node_modules/akanjs/vendor/use-agentic/index.ts": "export class Agentic {}\n",
+  "node_modules/akanjs/types/base/index.ts": "export class Declared {}\n",
+});
+
+describe("FrameworkGraph", () => {
+  it(`keeps ${FrameworkGraph.architectureFile} current with the source it describes`, async () => {
+    const architecture = await FrameworkGraph.architecture(workspaceRoot);
+    expect(architecture).not.toBeNull();
+    if (!architecture) return;
+    const { map } = architecture;
+    expect(map.missing).toEqual([]);
+    expect(map.cycles).toEqual([]);
+    expect(architecture.unknownClasses).toEqual([]);
+    const unmatched = map.channels.flatMap(({ name, messages }) =>
+      messages.flatMap(({ type, senders, handlers }) => [
+        ...(senders.length ? [] : [`${name} ${type} sender`]),
+        ...(handlers.length || handledInBrowser.has(name) ? [] : [`${name} ${type} handler`]),
+      ]),
+    );
+    expect(unmatched).toEqual(unrecognised);
+    if (architecture.next !== architecture.current)
+      throw new Error(`${FrameworkGraph.architectureFile} is stale. Regenerate it: bun run akan sync-architecture`);
+  });
+
+  it("reads a consumer's installed akanjs without its bundled vendor and declaration folders", async () => {
+    await withWorkspace({ "package.json": "{}" }, async (root) => {
+      expect(await FrameworkGraph.build(root)).toBeNull();
+    });
+    await withWorkspace(installed("3.1.0"), async (root) => {
+      expect(await FrameworkGraph.packagesOf(root)).toEqual([
+        { name: "akanjs", root: "node_modules/akanjs", split: true },
+      ]);
+      const map = await FrameworkGraph.build(root);
+      expect(map?.facets.map(({ id, layer, classes }) => `${id}:${layer}:${classes.map(({ name }) => name)}`)).toEqual([
+        "akanjs/base:0:Scalar",
+        "akanjs/native:0:Bridge",
+      ]);
+      expect(await FrameworkGraph.architecture(root)).toBeNull();
+    });
+  });
+
+  it("rebuilds an installed map on a new version, and an in-repo one on a save under it", async () => {
+    await withWorkspace(installed("3.1.0"), async (root) => {
+      const first = await FrameworkGraph.cached(root);
+      FrameworkGraph.touched(root, [path.join(root, "node_modules/akanjs/base/scalar.ts")]);
+      expect(await FrameworkGraph.cached(root)).toBe(first);
+      await writeFile(path.join(root, "node_modules/akanjs/package.json"), JSON.stringify({ version: "3.1.1" }));
+      expect(await FrameworkGraph.cached(root)).not.toBe(first);
+    });
+    await withWorkspace({ "pkgs/akanjs/base/scalar.ts": "export class Scalar {}\n" }, async (root) => {
+      const first = await FrameworkGraph.cached(root);
+      FrameworkGraph.touched(root, [path.join(root, "apps/demo/page/_index.tsx")]);
+      expect(await FrameworkGraph.cached(root)).toBe(first);
+      FrameworkGraph.touched(root, [path.join(root, "pkgs/akanjs/base/scalar.ts")]);
+      expect(await FrameworkGraph.cached(root)).not.toBe(first);
+    });
+  });
+
+  it("reads a document checked out with CRLF line endings as current", async () => {
+    const files = {
+      "pkgs/akanjs/base/scalar.ts": "export class Scalar {}\n",
+      [FrameworkGraph.architectureFile]: "# A\n",
+    };
+    await withWorkspace(files, async (root) => {
+      const first = await FrameworkGraph.architecture(root);
+      if (!first) throw new Error("no architecture");
+      await writeFile(path.join(root, FrameworkGraph.architectureFile), first.next.replace(/\n/g, "\r\n"));
+      const second = await FrameworkGraph.architecture(root);
+      expect(second?.current).toBe(first.next);
+      expect(second?.next).toBe(first.next);
+    });
+  });
+});

package/frameworkGraph.ts

@@ -0,0 +1,165 @@
+import { readdir, readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import {
+  type FrameworkChannelSpec,
+  FrameworkMapBuilder,
+  FrameworkMapDoc,
+  type FrameworkSourcePackage,
+} from "@akanjs/language";
+import type { FrameworkMap } from "akanjs/common";
+import ts from "typescript";
+
+const packageSpecs: Omit<FrameworkSourcePackage, "root">[] = [
+  { name: "akanjs", split: true },
+  { name: "@akanjs/devkit", split: false },
+];
+const channelSpecs: FrameworkChannelSpec[] = [
+  { file: "service/ipcTypes.ts", union: "AkanIpcMessage", label: "gateway ⇄ child" },
+  { file: "server/artifact/ipcTypes.ts", union: "BuilderMessage", label: "dev host ⇄ builder, relayed to the child" },
+  { file: "server/rscWorker.tsx", union: "InMsg", label: "server → RSC worker" },
+  { file: "server/rscWorkerHost.ts", union: "RscInMsg", label: "RSC worker → server" },
+  { file: "server/hmr/wsHub.ts", union: "HmrMessage", label: "dev server → browser tab", relays: ["HmrWsHub"] },
+];
+//? A published akanjs bundles use-agentic and @akanjs/native under `vendor/` and its declarations under `types/`;
+//? devkit's `integration`, `csrE2e` and `platformTest` are test harnesses that run in no framework process.
+const skippedDirs = new Set(["node_modules", "vendor", "types", "integration", "csrE2e", "platformTest"]);
+
+export interface FrameworkArchitecture {
+  file: string;
+  current: string;
+  next: string;
+  unknownClasses: string[];
+  map: FrameworkMap;
+}
+
+export class FrameworkGraph {
+  static readonly architectureFile = "pkgs/akanjs/ARCHITECTURE.md";
+  static readonly #cache = new Map<string, Promise<FrameworkMap | null>>();
+  static readonly #edits = new Map<string, number>();
+
+  static async packagesOf(workspaceRoot: string): Promise<FrameworkSourcePackage[]> {
+    const found = await Promise.all(
+      packageSpecs.map(async ({ name, split }) => {
+        const root = (await FrameworkGraph.#isDir(path.join(workspaceRoot, "pkgs", name)))
+          ? `pkgs/${name}`
+          : await FrameworkGraph.#installedRoot(workspaceRoot, name);
+        return root ? [{ name, root, split }] : [];
+      }),
+    );
+    return found.flat();
+  }
+
+  static async build(workspaceRoot: string): Promise<FrameworkMap | null> {
+    const packages = await FrameworkGraph.packagesOf(workspaceRoot);
+    const akanjs = packages.find(({ name }) => name === "akanjs");
+    if (!akanjs) return null;
+    const files = (
+      await Promise.all(packages.map(({ root }) => FrameworkGraph.#filesUnder(workspaceRoot, root)))
+    ).flat();
+    const texts = await Promise.all(
+      files.map(async (file) => [file, await readFile(path.join(workspaceRoot, file), "utf8")] as [string, string]),
+    );
+    return new FrameworkMapBuilder({
+      ts,
+      packages,
+      files: texts,
+      channels: channelSpecs.map((spec) => ({ ...spec, file: `${akanjs.root}/${spec.file}` })),
+    }).build();
+  }
+
+  //? Only the framework's own repository holds the document; a consumer's `node_modules/akanjs` is never rewritten.
+  static async architecture(workspaceRoot: string): Promise<FrameworkArchitecture | null> {
+    const file = path.join(workspaceRoot, FrameworkGraph.architectureFile);
+    const current = await readFile(file, "utf8")
+      .then((text) => text.replace(/\r\n/g, "\n"))
+      .catch(() => null);
+    const map = current === null ? null : await FrameworkGraph.build(workspaceRoot);
+    if (current === null || !map || map.packages.find(({ name }) => name === "akanjs")?.root !== "pkgs/akanjs")
+      return null;
+    const next = FrameworkMapDoc.splice(
+      current,
+      FrameworkMapDoc.render(map, path.posix.dirname(FrameworkGraph.architectureFile)),
+    );
+    return {
+      file,
+      current,
+      next,
+      unknownClasses: FrameworkMapDoc.unknownClasses(next, map),
+      map,
+    };
+  }
+
+  static touched(workspaceRoot: string, files: string[]) {
+    const roots = packageSpecs.map(({ name }) => path.join(workspaceRoot, "pkgs", name) + path.sep);
+    if (files.some((file) => roots.some((root) => path.resolve(workspaceRoot, file).startsWith(root))))
+      FrameworkGraph.#edits.set(workspaceRoot, (FrameworkGraph.#edits.get(workspaceRoot) ?? 0) + 1);
+  }
+
+  //? Only an install rewrites `node_modules/akanjs`, and an install changes its version.
+  static async cached(workspaceRoot: string): Promise<FrameworkMap | null> {
+    const packages = await FrameworkGraph.packagesOf(workspaceRoot);
+    const stamps = await Promise.all(
+      packages.map(async ({ name, root }) =>
+        root.startsWith("pkgs/")
+          ? `${name}#${FrameworkGraph.#edits.get(workspaceRoot) ?? 0}`
+          : `${name}@${await FrameworkGraph.#versionOf(path.join(workspaceRoot, root))}`,
+      ),
+    );
+    const cacheKey = [workspaceRoot, ...stamps].join("\n");
+    const existing = FrameworkGraph.#cache.get(cacheKey);
+    if (existing) return await existing;
+    const built = FrameworkGraph.build(workspaceRoot);
+    built.catch(() => FrameworkGraph.#cache.delete(cacheKey));
+    FrameworkGraph.#cache.clear();
+    FrameworkGraph.#cache.set(cacheKey, built);
+    return await built;
+  }
+
+  //? Bun resolves a bare name from its global cache when no `node_modules` exists, so one must; an install linked from
+  //? outside the workspace is skipped, as its files have no workspace-relative path.
+  static async #installedRoot(workspaceRoot: string, name: string): Promise<string | null> {
+    if (!(await FrameworkGraph.#isDir(path.join(workspaceRoot, "node_modules")))) return null;
+    const resolved = await (async () => {
+      try {
+        return path.dirname(await realpath(Bun.resolveSync(`${name}/package.json`, workspaceRoot)));
+      } catch {
+        const dir = path.join(workspaceRoot, "node_modules", name);
+        return (await FrameworkGraph.#isDir(dir)) ? await realpath(dir) : null;
+      }
+    })();
+    if (!resolved) return null;
+    const root = path
+      .relative(await realpath(workspaceRoot), resolved)
+      .split(path.sep)
+      .join("/");
+    return root && !root.startsWith("..") && !path.isAbsolute(root) ? root : null;
+  }
+
+  static async #versionOf(dir: string) {
+    return await readFile(path.join(dir, "package.json"), "utf8")
+      .then((text) => (JSON.parse(text) as { version?: string }).version ?? "")
+      .catch(() => "");
+  }
+
+  static async #isDir(dir: string) {
+    return await stat(dir)
+      .then((info) => info.isDirectory())
+      .catch(() => false);
+  }
+
+  static async #filesUnder(workspaceRoot: string, root: string): Promise<string[]> {
+    const entries = await readdir(path.join(workspaceRoot, root), { withFileTypes: true });
+    const files: string[] = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || skippedDirs.has(entry.name)) continue;
+      if (entry.isFile()) files.push(`${root}/${entry.name}`);
+      else if (entry.isDirectory())
+        for await (const file of new Bun.Glob("**/*.{ts,tsx}").scan({
+          cwd: path.join(workspaceRoot, root, entry.name),
+        }))
+          if (!file.split(path.sep).includes("node_modules"))
+            files.push(`${root}/${entry.name}/${file.split(path.sep).join("/")}`);
+    }
+    return files.filter((file) => FrameworkMapBuilder.isSourcePath(file)).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  }
+}

package/frontendBuild/allRoutesBuilder.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from "bun:test";
+import { mkdir, realpath, symlink } from "node:fs/promises";
+import path from "node:path";
+import { tempDirs, writeText as write } from "../testHelpers";
+import { AllRoutesBuilder } from "./allRoutesBuilder";
+
+const makeTempRoot = tempDirs("akan-all-routes-");
+const akanjsRoot = path.resolve(import.meta.dir, "../../../akanjs");
+
+const linkPackage = async (root: string, name: string, dir: string) => {
+  await mkdir(path.join(root, "node_modules"), { recursive: true });
+  await symlink(dir, path.join(root, "node_modules", name));
+};
+
+//? As this monorepo maps it, so the generated root layout's `akanjs/ui/System/index.tsx` resolves through a wildcard.
+const paths = { "@apps/*": ["./apps/*"], "akanjs/*": ["./node_modules/akanjs/*"] };
+
+const writeApp = async () => {
+  const root = await realpath(await makeTempRoot());
+  const appDir = path.join(root, "apps/demo");
+  await linkPackage(root, "akanjs", akanjsRoot);
+  await linkPackage(root, "react", path.dirname(Bun.resolveSync("react/package.json", akanjsRoot)));
+  await write(path.join(root, "tsconfig.json"), JSON.stringify({ compilerOptions: { paths } }));
+  await write(path.join(appDir, "client.ts"), "export {};\n");
+  await write(path.join(appDir, "env/env.client.ts"), "export const env = {};\n");
+  await write(path.join(appDir, "lib/dict.ts"), "export const getAllDictionary = () => ({});\n");
+  await write(path.join(appDir, "ui/Home.tsx"), '"use client";\nexport const Home = () => "home-marker";\n');
+  await write(path.join(appDir, "ui/Memo.tsx"), '"use client";\nexport const Memo = () => "memo-marker";\n');
+  await write(
+    path.join(appDir, "page/_index.tsx"),
+    'import { Home } from "../ui/Home";\nexport default function Page() {\n  return <Home />;\n}\n',
+  );
+  await write(
+    path.join(appDir, "page/memo.tsx"),
+    'import { Memo } from "../ui/Memo";\nexport default function Page() {\n  return <Memo />;\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"],
+    getConfig: async () => ({ basePaths: [], optimizeImports: [], barrelImports: [] }),
+    getTsConfig: async () => ({ compilerOptions: { paths } }),
+    getPublicEnv: () => ({}),
+    log: () => undefined,
+    verbose: () => undefined,
+    logger: { warn: () => undefined },
+  };
+  return app;
+};
+
+describe("AllRoutesBuilder", () => {
+  test("writes the route manifest, then the preload table once the runtime chunks are known, and each route's modules", 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(await Bun.file(manifestPath).json()).not.toHaveProperty("modulePreloads");
+
+    const runtimeChunks = { runtime: ["/_akan/client/rsc.js"], vendors: { react: ["/_akan/client/react.js"] } };
+    const preloads = await routes.writeModulePreloads(runtimeChunks);
+    expect(preloads.table).toMatchObject(runtimeChunks);
+    expect(new Set(Object.values(preloads.table.chunkVendors).flat())).toEqual(new Set(["react"]));
+    expect((await Bun.file(manifestPath).json()).modulePreloads).toEqual(preloads.table);
+
+    const chunksOf = (suffix: string) =>
+      Object.entries(manifest.clientManifest).find(([key]) => key.endsWith(suffix))?.[1].chunks ?? [];
+    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 modules = preloads.modulesByRoute();
+    expect(shell.length).toBeGreaterThan(0);
+    for (const [routeId, own, other] of [
+      ["/:lang", home, memo],
+      ["/:lang/memo", memo, home],
+    ] as const) {
+      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);
+    }
+  }, 30_000);
+});

package/frontendBuild/allRoutesBuilder.ts

@@ -1,11 +1,12 @@
 import path from "node:path";
-import type { BaseBuildArtifact, BuildRouteClientResult, RoutesManifest } from "akanjs/server";
+import type { RoutesManifest } from "akanjs/server";
 import { resolveSsrPageEntriesForApp } from "../artifact/implicitRootLayout";
 import { computeRouteSeedIndex, type RouteSeedIndex } from "../artifact/routeSeedIndex";
 import type { App } from "../commandDecorators";
 import type { ClientEntryDiscovery } from "./clientBuildTypes";
 import { GraphClientEntryDiscovery } from "./clientEntryDiscovery";
-import { RouteClientBuilder } from "./routeClientBuilder";
+import { type BuildRouteClientResult, RouteClientBuilder } from "./routeClientBuilder";
+import { RouteModulePreloads, type RuntimeChunks } from "./routeModulePreloads";
 import { RoutesManifestArtifactSerializer } from "./routesManifestArtifactSerializer";
 
 export interface BuildAllRoutesResult {
@@ -16,7 +17,6 @@ export interface BuildAllRoutesResult {
 
 export class AllRoutesBuilder {
   #app: App;
-  #artifact: BaseBuildArtifact;
   #command: "build" | "start";
   #artifactDir: string;
   #merged: Pick<RoutesManifest, "clientManifest" | "ssrManifest" | "knownEntries"> = {
@@ -26,11 +26,12 @@ export class AllRoutesBuilder {
   };
   #knownSet = new Set<string>();
   #routeIds: string[] = [];
+  #entriesByRoute = new Map<string, string[]>();
+  #externalsByChunkUrl: Record<string, string[]> = {};
   #discovery: ClientEntryDiscovery | null = null;
 
-  constructor(app: App, artifact: BaseBuildArtifact, command: "build" | "start" = "start") {
+  constructor(app: App, command: "build" | "start" = "start") {
     this.#app = app;
-    this.#artifact = artifact;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
   }
@@ -46,7 +47,9 @@ export class AllRoutesBuilder {
     const allEntries = new Set<string>();
     for (const entry of seedIndex.entries) {
       const seeds = Array.from(new Set([...seedIndex.globalLayoutFiles, ...entry.seeds]));
-      for (const discovered of await this.#discovery.discover(seeds)) allEntries.add(discovered);
+      const routeEntries = await this.#discovery.discover(seeds);
+      for (const discovered of routeEntries) allEntries.add(discovered);
+      this.#entriesByRoute.set(entry.routeId, routeEntries);
       this.#routeIds.push(entry.routeId);
     }
     this.#app.verbose(`[build-all] ${allEntries.size} client entries across ${this.#routeIds.length} routes`);
@@ -54,11 +57,33 @@ export class AllRoutesBuilder {
     const delta = await this.#buildEntries([...allEntries]);
     this.#mergeDelta(delta);
     this.#merged.knownEntries = Array.from(this.#knownSet);
+    this.#externalsByChunkUrl = delta.externalsByChunkUrl ?? {};
 
     const manifest: RoutesManifest = {
       routeIds: this.#routeIds,
       ...this.#merged,
     };
+    const manifestPath = await this.#writeManifest(manifest);
+    this.#app.verbose(
+      `[build-all] wrote ${manifestPath} routes=${this.#routeIds.length} entries=${this.#merged.knownEntries.length}`,
+    );
+
+    return { manifest, manifestPath, seedIndex };
+  }
+
+  async writeModulePreloads(runtimeChunks: RuntimeChunks): Promise<RouteModulePreloads> {
+    const preloads = new RouteModulePreloads({
+      runtimeChunks,
+      entriesByRoute: this.#entriesByRoute,
+      clientManifest: this.#merged.clientManifest,
+      externalsByChunkUrl: this.#externalsByChunkUrl,
+      workspaceRoot: this.#app.workspace.workspaceRoot,
+    });
+    await this.#writeManifest({ routeIds: this.#routeIds, ...this.#merged, modulePreloads: preloads.table });
+    return preloads;
+  }
+
+  async #writeManifest(manifest: RoutesManifest) {
     const manifestPath = path.join(path.resolve(this.#artifactDir), "routes-manifest.json");
     await Bun.write(
       manifestPath,
@@ -70,11 +95,7 @@ export class AllRoutesBuilder {
         2,
       )}\n`,
     );
-    this.#app.verbose(
-      `[build-all] wrote ${manifestPath} routes=${this.#routeIds.length} entries=${this.#merged.knownEntries.length}`,
-    );
-
-    return { manifest, manifestPath, seedIndex };
+    return manifestPath;
   }
 
   async #buildEntries(entries: string[]): Promise<BuildRouteClientResult> {
@@ -91,7 +112,6 @@ export class AllRoutesBuilder {
       app: this.#app,
       seeds: [],
       entries,
-      artifact: this.#artifact,
       knownEntries: this.#knownSet,
       discovery: this.#discovery,
       command: this.#command,