@akanjs/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/{applicationBuildRunner-kxwbssgn.js → applicationBuildRunner-qkt6spd5.js}

@@ -1,22 +1,55 @@
 // @bun
 import {
   Spinner
-} from "./index-2tv3fdx4.js";
+} from "./index-n3jk2501.js";
+import"./index-6x9p8dpb.js";
 import {
   AllRoutesBuilder,
   CsrArtifactBuilder,
   FontPruner,
   precompressArtifacts,
   SsrBaseArtifactBuilder
-} from "./index-a64esmtb.js";
-import"./index-w8kmx1b6.js";
-import"./index-q0y2jq9j.js";
-import"./index-hwkygn9s.js";
+} from "./index-376gpdds.js";
+import"./index-52w0fvh8.js";
 import"./index-n68jx79w.js";
 
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import { mkdir, rm } from "fs/promises";
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/transforms/serverEnvPlugin.ts
+import { existsSync, realpathSync } from "fs";
 import path from "path";
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var createServerEnvPlugin = ({ envDir, environment, environments }) => {
+  const others = [...new Set(environments)].filter((name) => name !== environment);
+  const dirs = new Set([path.resolve(envDir), existsSync(envDir) ? realpathSync.native(envDir) : envDir]);
+  const names = others.map(escapeRegExp).join("|");
+  const filter = new RegExp(`^(?:${[...dirs].map(escapeRegExp).join("|")})[\\\\/]env\\.server\\.(?:${names})\\.ts$`);
+  return {
+    name: "akan-server-env",
+    setup(build) {
+      if (!others.length)
+        return;
+      build.onLoad({ filter }, async (args) => {
+        const name = path.basename(args.path, ".ts").slice("env.server.".length);
+        const { exports } = new Bun.Transpiler({ loader: "ts" }).scan(await Bun.file(args.path).text());
+        const message = `env/env.server.${name}.ts is not in this build: \`akan build\` bundles the server env of AKAN_PUBLIC_ENV=${environment} alone, the environment its image runs. To run ${name}, build for it: AKAN_PUBLIC_ENV=${name} in the workspace's .env, which outranks the shell, or --env ${name} on a desktop or mobile build.`;
+        return {
+          loader: "js",
+          contents: [
+            `const refuse = () => { throw new Error(${JSON.stringify(message)}); };`,
+            "const unbuilt = new Proxy({}, { get: refuse, has: refuse, ownKeys: refuse, getOwnPropertyDescriptor: refuse });",
+            `export { ${exports.map((exported) => `unbuilt as ${JSON.stringify(exported)}`).join(", ")} };`
+          ].join(`
+`)
+        };
+      });
+    }
+  };
+};
+
+// pkgs/@akanjs/devkit/applicationBuildRunner.ts
 var BUILD_PHASE_EMOJIS = {
   prepare: "\uD83E\uDDF9",
   typecheck: "\uD83D\uDD0E",
@@ -51,54 +84,52 @@ class ApplicationBuildRunner {
   #app;
   #fast;
   #reporter;
+  #environment;
+  #spinner;
   #startedAt = Date.now();
   #phases = [];
-  constructor(app, { fast = false, reporter } = {}) {
+  constructor(app, { fast = false, reporter, environment } = {}) {
     this.#app = app;
     this.#fast = fast;
     this.#reporter = reporter;
+    this.#environment = environment;
   }
   async build({ spinner = false } = {}) {
-    const phaseOptions = { spinner };
+    this.#spinner = spinner;
     const { web, assets } = await this.#app.getConfig();
-    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
-      spinner
-    });
+    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"));
     if (!this.#fast)
-      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck(), undefined, phaseOptions);
-    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`, phaseOptions);
-    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr", phaseOptions);
-    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await this.#buildCsr() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"), phaseOptions);
-    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts", phaseOptions);
-    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files", phaseOptions);
-    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta(), undefined, {
-      spinner
-    });
+      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck());
+    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`);
+    await this.#runPhase("ssr", "Building SSR route artifacts", async () => web.ssr ? await this.#buildSsr() : null, (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : web.ssr ? "skipped" : "disabled by akan.config.ts web.ssr");
+    await this.#runPhase("csr", "Building CSR assets", async () => web.csr ? await new CsrArtifactBuilder(this.#app, "build").build() : null, (result) => result?.outputDir ?? (web.csr ? "skipped" : "disabled by akan.config.ts web.csr"));
+    await this.#runPhase("assets", "Trimming unread static assets", async () => assets.pruneFonts ? await new FontPruner(this.#app, assets).prune() : null, (result) => result ? `${result.removed.length} font file(s) dropped, ${ApplicationBuildRunner.formatBytes(result.freedBytes)} freed; ${result.kept.length} kept` : "disabled by akan.config.ts assets.pruneFonts");
+    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> gzip ${ApplicationBuildRunner.formatBytes(result.outputBytes)} / br ${ApplicationBuildRunner.formatBytes(result.brotliBytes)}` : "no files");
+    await this.#runPhase("metadata", "Writing production metadata", () => this.buildAppMeta());
     return {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path2.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
     const { clean = false, incremental = true } = options;
     await this.#app.getPageKeys({ refresh: true });
-    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
+    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig(incremental);
     if (clean)
-      await rm(path.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm(path2.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
-  async#runPhase(id, label, task, summarize, options = {}) {
+  async#runPhase(id, label, task, summarize) {
     this.#reporter?.phaseStart?.({ id, label });
     const phaseStartedAt = Date.now();
-    const spinner = options.spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
+    const spinner = this.#spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
     try {
       const result = await task();
       const phase = { id, label, durationMs: Date.now() - phaseStartedAt, summary: summarize?.(result) };
       this.#phases.push(phase);
-      const summary = phase.summary ? `: ${phase.summary}` : "";
-      spinner?.succeed(`${label}${summary}`);
+      spinner?.succeed(`${label}${phase.summary ? `: ${phase.summary}` : ""}`);
       this.#reporter?.phaseDone?.(phase);
       return result;
     } catch (error) {
@@ -107,63 +138,85 @@ class ApplicationBuildRunner {
       throw error;
     }
   }
-  async#buildAppMeta() {
+  async buildAppMeta() {
     const akanConfig = await this.#app.getConfig();
+    const dockerfile = akanConfig.dockerfileFor(this.#environment ?? akanConfig.baseDevEnv.env);
     await Promise.all([
       this.#app.dist.writeJson("package.json", akanConfig.getProductionPackageJson()),
-      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.dockerfile)
+      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, dockerfile),
+      this.#app.dist.writeJson("akan.build.json", {
+        buildId: await this.#resolveBuildId(),
+        akanVersion: akanConfig.akanVersion,
+        builtAt: new Date().toISOString()
+      })
     ]);
   }
+  async#resolveBuildId() {
+    const fromEnv = process.env.AKAN_BUILD_ID?.trim();
+    if (fromEnv)
+      return fromEnv;
+    const root = this.#app.workspace.workspaceRoot;
+    const sha = Bun.spawnSync(["git", "rev-parse", "--short=12", "HEAD"], { cwd: root, stderr: "ignore" });
+    if (sha.exitCode !== 0)
+      return null;
+    const dirty = Bun.spawnSync(["git", "status", "--porcelain", "--untracked-files=no"], {
+      cwd: root,
+      stderr: "ignore"
+    });
+    const suffix = dirty.exitCode === 0 && dirty.stdout.toString().trim() ? "-dirty" : "";
+    return `${sha.stdout.toString().trim()}${suffix}`;
+  }
   async#buildBackend() {
-    const akanConfig = await this.#app.getConfig();
-    const backendExternals = [
-      ...new Set([...akanConfig.externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS])
-    ];
-    const { web } = akanConfig;
+    const { externalLibs, web, baseDevEnv, branches } = await this.#app.getConfig();
     const backendEntryPoints = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     for (const entrypoint of backendEntryPoints) {
       if (!await Bun.file(entrypoint).exists())
         throw new Error(`Backend entrypoint not found: ${entrypoint}`);
     }
-    const backendResult = await this.#buildOrThrow("backend", {
-      entrypoints: backendEntryPoints,
+    const sharedConfig = {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: AKAN_BACKEND_MINIFY,
       naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+    };
+    const serverEnvPlugin = createServerEnvPlugin({
+      envDir: path2.join(this.#app.cwdPath, "env"),
+      environment: this.#environment ?? baseDevEnv.env,
+      environments: ["local", "testing", ...branches]
     });
+    const backendConfig = {
+      ...sharedConfig,
+      plugins: [this.#createExternalSpecifiersPlugin(externalLibs), serverEnvPlugin]
+    };
+    const [mainResult, serverResult] = [
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[0]] }),
+      await this.#buildOrThrow("backend", { ...backendConfig, entrypoints: [backendEntryPoints[1]], splitting: true })
+    ];
     const rscWorkerResult = web.ssr ? await this.#buildOrThrow("rsc-worker", {
+      ...backendConfig,
       entrypoints: [this.#resolveRscWorkerBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
-      conditions: ["react-server"],
-      define: { "process.env.NODE_ENV": JSON.stringify("production") },
-      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+      conditions: ["react-server"]
     }) : null;
     const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      ...sharedConfig,
       entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
-      outdir: this.#app.dist.cwdPath,
-      target: "bun",
-      minify: AKAN_BACKEND_MINIFY,
-      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
-      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" }
     });
     await this.#writeConsoleShim();
+    const results = [mainResult, serverResult, rscWorkerResult, consoleRuntimeResult];
     return {
       entrypoints: backendEntryPoints.length + (rscWorkerResult ? 2 : 1),
-      outputs: backendResult.outputs.length + (rscWorkerResult?.outputs.length ?? 0) + consoleRuntimeResult.outputs.length + 1
+      outputs: results.reduce((sum, result) => sum + (result?.outputs.length ?? 0), 1)
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
-import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+    await Bun.write(path2.join(this.#app.dist.cwdPath, "console.js"), `process.env.AKAN_COMMAND_TYPE = "console";
+const { cnst, db, dict, option, server, sig, srv } = await import("./server.js");
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("./console-runtime.js");
 
 const run = async () => {
-  assertAkanConsoleAllowed(server.env);
+  assertAkanConsoleAllowed();
   await server.start({ listen: false, web: false });
   try {
     await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
@@ -182,19 +235,16 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path2.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path.join(path.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path2.join(path2.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path2.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
-  async#buildCsr() {
-    return await new CsrArtifactBuilder(this.#app, "build").build();
-  }
   async#buildSsr() {
     const pageKeys = await this.#app.getPageKeys();
     if (pageKeys.length === 0) {
@@ -205,11 +255,11 @@ void run().catch((error) => {
     const allRoutes = await new AllRoutesBuilder(this.#app, base.artifact, "build").build();
     return { base, allRoutes };
   }
-  async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path.join(this.#app.cwdPath, ".akan", "typecheck");
+  async#writeTypecheckTsconfig(incremental) {
+    const typecheckDir = path2.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir(typecheckDir, { recursive: true });
     const libPageIncludes = (await this.#app.getPageRoots()).filter((root) => root.keyPrefix).flatMap((root) => {
-      const rel = path.relative(typecheckDir, root.realDir).split(path.sep).join("/");
+      const rel = path2.relative(typecheckDir, root.realDir).split(path2.sep).join("/");
       return [`${rel}/**/*.ts`, `${rel}/**/*.tsx`];
     });
     const tsconfig = {
@@ -230,7 +280,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path2.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -256,10 +306,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path.join(import.meta.dir, "typecheck.proc.js"),
-      path.join(import.meta.dir, "typecheck.proc.ts")
+      path2.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path2.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path2.join(import.meta.dir, "typecheck.proc.js"),
+      path2.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -272,9 +322,9 @@ void run().catch((error) => {
       throw new AggregateError(result.logs, `[${label}] Bun.build failed`);
     return result;
   }
-  #createExternalSpecifiersPlugin(specifiers) {
-    const uniqueSpecifiers = [...new Set(specifiers)];
-    const escaped = uniqueSpecifiers.map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  #createExternalSpecifiersPlugin(externalLibs) {
+    const specifiers = new Set([...externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS]);
+    const escaped = [...specifiers].map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
     const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
     return {
       name: "akan-backend-externalize-specifiers",
@@ -283,13 +333,7 @@ void run().catch((error) => {
       }
     };
   }
-  static formatBytes(bytes) {
-    if (bytes < 1024)
-      return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-      return `${(bytes / 1024).toFixed(1)}KB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
-  }
+  static formatBytes = FontPruner.formatBytes;
 }
 export {
   ApplicationBuildRunner

package/buildBatch.proc.js

@@ -1,24 +1,33 @@
 // @bun
 import {
+  ApplicationBuildReporter
+} from "./index-48k96p55.js";
+import {
+  resolveSsrPageEntriesForApp,
   WorkspaceExecutor,
   AppExecutor
-} from "./index-2tv3fdx4.js";
-import"./index-q0y2jq9j.js";
-import"./index-6wwzs1bc.js";
+} from "./index-n3jk2501.js";
 import {
-  CssCompiler,
+  computeRouteSeedIndex,
+  saveRouteSeedIndex,
+  ServerGraphFile,
   PagesBundleBuilder,
+  CsrDevBundler,
+  SsrDevBundler
+} from "./index-6x9p8dpb.js";
+import"./index-52w0fvh8.js";
+import {
   CsrArtifactBuilder,
+  CssCompiler,
   FontOptimizer,
   SsrBaseArtifactBuilder
-} from "./index-a64esmtb.js";
-import"./index-w8kmx1b6.js";
-import"./index-hwkygn9s.js";
+} from "./index-376gpdds.js";
 import"./index-n68jx79w.js";
 
 // pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts
 import path from "path";
 import { Logger } from "akanjs/common";
+import { resolveDevCsrMode } from "akanjs/server/hmr/csrDevManifest";
 
 class BuildBatch {
   #logger = new Logger("BuildBatch");
@@ -35,15 +44,23 @@ class BuildBatch {
       await this.#buildBase();
     if (this.#request.needs.includes("csr"))
       await this.#buildCsr();
-    if (this.#request.needs.includes("pages"))
-      await this.#buildPages();
+    if (this.#request.needs.includes("ssr"))
+      await this.#buildSsrRegistry();
     if (this.#request.needs.includes("css"))
       await this.#buildCss();
+    if (this.#request.needs.includes("pages"))
+      await this.#buildPages();
     return this.#result;
   }
   #emit(message) {
     process.send?.(message);
   }
+  #sentTrace() {
+    if (!this.#request.trace)
+      return;
+    const now = Date.now();
+    return { ...this.#request.trace, patchAt: now, sentAt: now };
+  }
   #emitStatus(phase, message) {
     this.#emit({
       type: "build-status",
@@ -56,6 +73,13 @@ class BuildBatch {
       }
     });
   }
+  #fail(need, label, err) {
+    const message = ApplicationBuildReporter.formatError(err, this.#request.workspaceRoot);
+    this.#logger.error(`${label} failed: ${message}`);
+    this.#result.errors[need] = message;
+    if (need !== "base")
+      this.#emitStatus(need, message);
+  }
   async#buildBase() {
     const started = Date.now();
     try {
@@ -64,44 +88,106 @@ class BuildBatch {
       this.#result.optimizedFonts = optimizedFonts;
       this.#logger.verbose(`base-artifact ok buildId=${artifact.pagesBundleBuildId} (${Date.now() - started}ms)`);
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.#logger.error(`base-artifact failed: ${message}`);
-      this.#result.errors.base = message;
+      this.#fail("base", "base-artifact", err);
     }
   }
   async#buildCsr() {
     const started = Date.now();
     try {
-      await new CsrArtifactBuilder(this.#app).build();
-      this.#logger.verbose(`csr-rebundle ok (${Date.now() - started}ms)`);
+      if (resolveDevCsrMode() === "registry")
+        await this.#updateCsrRegistry(started);
+      else
+        await this.#rebuildCsrArtifact(started);
       this.#emitStatus("csr");
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.#logger.error(`csr-rebundle failed: ${message}`);
-      this.#result.errors.csr = message;
-      this.#emitStatus("csr", message);
+      this.#fail("csr", "csr-rebundle", err);
+    }
+  }
+  async#rebuildCsrArtifact(started) {
+    await new CsrArtifactBuilder(this.#app).build();
+    this.#logger.verbose(`csr-rebundle ok (${Date.now() - started}ms)`);
+    if (this.#request.changedFiles.length === 0)
+      return;
+    this.#emit({
+      type: "csr-updated",
+      data: { generation: Date.now(), mode: "artifact", reload: true, reason: "the CSR artifact was rebuilt" }
+    });
+  }
+  async#updateCsrRegistry(started) {
+    const update = await new CsrDevBundler(this.#app).update(this.#request.changedFiles, {
+      announce: (announced) => this.#emit({
+        type: "csr-updated",
+        data: {
+          generation: announced.generation,
+          mode: "registry",
+          reload: announced.reload,
+          reason: announced.reason,
+          patchUrl: announced.patchUrl,
+          changedIds: announced.changedIds,
+          trace: this.#sentTrace()
+        }
+      })
+    });
+    if (!update) {
+      this.#logger.verbose(`csr-dev unchanged (${Date.now() - started}ms)`);
+      return;
+    }
+    this.#logger.verbose(`csr-dev generation=${update.generation} ${update.reload ? `reload (${update.reason})` : `patch modules=${update.changedIds.length}`} graph=${update.moduleCount} (${Date.now() - started}ms)`);
+  }
+  async#buildSsrRegistry() {
+    const started = Date.now();
+    try {
+      const bundler = new SsrDevBundler(this.#app);
+      const hold = await ServerGraphFile.touches(await ServerGraphFile.read(this.#request.artifactDir), this.#request.changedFiles, (file) => ServerGraphFile.clientExportsOf(file));
+      const update = await bundler.update(this.#request.changedFiles, {
+        roots: await bundler.clientEntries(),
+        announce: (announced) => this.#emit({
+          type: "ssr-updated",
+          data: {
+            generation: announced.generation,
+            reload: announced.reload,
+            reason: announced.reason,
+            patchUrl: announced.patchUrl,
+            changedIds: announced.changedIds,
+            trace: this.#sentTrace(),
+            ...announced.epoch !== undefined ? { epoch: announced.epoch } : {},
+            ...announced.first ? { first: true } : {},
+            ...hold && this.#request.changedFiles.length > 0 ? { hold, batchGeneration: this.#request.generation } : {}
+          }
+        })
+      });
+      this.#emitStatus("ssr");
+      this.#logger.verbose(update ? `ssr-dev generation=${update.generation} ${update.reload ? `reload (${update.reason})` : `patch modules=${update.changedIds.length}`} graph=${update.moduleCount} (${Date.now() - started}ms)` : `ssr-dev unchanged (${Date.now() - started}ms)`);
+    } catch (err) {
+      this.#fail("ssr", "ssr-dev", err);
     }
   }
   async#buildPages() {
     const started = Date.now();
     try {
-      const next = await new PagesBundleBuilder(this.#app).build();
+      const pageEntries = await resolveSsrPageEntriesForApp(this.#app, await this.#app.getPageKeys());
+      const seedIndex = computeRouteSeedIndex(pageEntries);
+      const previousGraph = await ServerGraphFile.read(this.#request.artifactDir);
+      const next = await new PagesBundleBuilder(this.#app, "start", pageEntries).build();
+      await saveRouteSeedIndex(this.#request.artifactDir, seedIndex);
+      const nextGraph = await ServerGraphFile.read(this.#request.artifactDir);
+      const serverTouched = await ServerGraphFile.touches(previousGraph, [...this.#request.changedFiles, ...previousGraph?.carried ?? []], (file) => nextGraph?.clientExports[file] ?? null, nextGraph);
       this.#emit({
         type: "pages-updated",
         data: {
           bundlePath: next.bundlePath,
           buildId: next.buildId,
           generation: this.#request.generation,
-          changedFiles: this.#request.changedFiles
+          changedFiles: this.#request.changedFiles,
+          trace: this.#sentTrace(),
+          serverTouched
         }
       });
       this.#emitStatus("pages");
       this.#logger.verbose(`pages-rebundle ok buildId=${next.buildId} (${Date.now() - started}ms)`);
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.#logger.error(`pages-rebundle failed: ${message}`);
-      this.#result.errors.pages = message;
-      this.#emitStatus("pages", message);
+      this.#fail("pages", "pages-rebundle", err);
+      await ServerGraphFile.carry(this.#request.artifactDir, this.#request.changedFiles).catch((carryError) => this.#logger.warn(`server graph carry failed; the next save may skip its RSC refresh: ${String(carryError)}`));
     }
   }
   async#buildCss() {
@@ -143,10 +229,7 @@ ${cssText}`).toString(36);
       });
       this.#logger.verbose(`css-compile ok assets=${Object.keys(cssAssets).length} (${Date.now() - started}ms)`);
     } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      this.#logger.error(`css-rebuild failed: ${message}`);
-      this.#result.errors.css = message;
-      this.#emitStatus("css", message);
+      this.#fail("css", "css-rebuild", err);
     }
   }
   async#optimizeFonts() {
@@ -162,8 +245,6 @@ ${cssText}`).toString(36);
     return optimizedFonts;
   }
   static #shouldReoptimizeFonts(previous, changedFiles) {
-    if (changedFiles.length === 0)
-      return false;
     return changedFiles.some((file) => {
       const normalized = path.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
@@ -175,7 +256,11 @@ ${cssText}`).toString(36);
     const raw = process.argv[2];
     if (!raw)
       throw new Error("[build-batch] missing request argument");
-    const request = JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    const request = parsed.trace ? {
+      ...parsed,
+      trace: { ...parsed.trace, workerStartAt: Math.round(performance.timeOrigin), workerAt: Date.now() }
+    } : parsed;
     const workspace = WorkspaceExecutor.fromRoot({
       workspaceRoot: request.workspaceRoot,
       repoName: request.repoName
@@ -183,11 +268,14 @@ ${cssText}`).toString(36);
     const app = AppExecutor.from(workspace, request.appName);
     if (request.pageKeys)
       app.setPageKeys(request.pageKeys);
+    const orphaned = () => process.exit(1);
+    process.on("disconnect", orphaned);
     const result = await new BuildBatch(request, app).run();
     process.send?.({ type: "build-batch-result", data: result });
+    process.off("disconnect", orphaned);
   }
 }
-BuildBatch.main().catch((err) => {
+await BuildBatch.main().catch((err) => {
   console.error(err);
   process.exit(1);
 });