@akanjs/devkit 3.0.0-beta.23 → 3.0.0-beta.25

package/incrementalBuilder/incrementalBuilder.host.ts

@@ -1,6 +1,8 @@
+import fs from "node:fs";
 import path from "node:path";
 import { Logger } from "akanjs/common";
 import type { BuilderMessage } from "akanjs/server";
+import { CSR_DEV_DIRNAME, CSR_DEV_PATCHING_MARKER, SSR_DEV_DIRNAME } from "akanjs/server/hmr/csrDevManifest";
 import { MemoryLimit } from "akanjs/server/memoryLimit";
 import type { App } from "../commandDecorators";
 
@@ -11,8 +13,11 @@ const builderMsgTypeSet = new Set<BuilderMessage["type"]>([
   "invalidate",
   "css-updated",
   "pages-updated",
+  "csr-updated",
+  "ssr-updated",
   "build-status",
   "builder-metrics",
+  "boot-armed",
 ]);
 /** Prefer `"pipe"` under a TUI: a Bun child that inherits the terminal restores its spawn-time termios on exit. */
 export type DevStdioMode = "inherit" | "pipe";
@@ -44,8 +49,9 @@ export class IncrementalBuilderHost {
   static readonly #restartBaseDelayMs = 1_000;
   static readonly #restartMaxDelayMs = 30_000;
   static readonly #recycleDrainTimeoutMs = 30_000;
-  // A fresh boot is ~300-600MB; this leaves room for one full rebuild on top.
-  static readonly #devMaxRssBytes = 1_200 * 1024 * 1024;
+  // apps/akan's builder peaks near 950MB holding the SSR registry's patcher through a route build, and arming CSR adds
+  // a second patcher: this recycles only a builder grown well past both.
+  static readonly #devMaxRssBytes = 2_048 * 1024 * 1024;
   logger = new Logger("IncrementalBuilderHost");
   entry: string;
   env: Record<string, string>;
@@ -61,6 +67,7 @@ export class IncrementalBuilderHost {
   #recycleTimer: ReturnType<typeof setTimeout> | null = null;
   #recycleRequested: boolean = false;
   #spawnAfterRecycle: boolean = false;
+  #patcherOff: boolean = false;
   #manualStop = false;
   // Nothing else answers a request whose builder exits holding it: a crash or kill sends nothing, and a drain races
   // its own exit, so an unanswered page request would spin forever.
@@ -94,10 +101,16 @@ export class IncrementalBuilderHost {
     this.ready = false;
     const afterRecycle = this.#spawnAfterRecycle;
     this.#spawnAfterRecycle = false;
+    this.#checkPatchingMarker(isRestart && !afterRecycle);
     let proc!: Bun.Subprocess<"ignore", "inherit" | "pipe", "inherit" | "pipe">;
     proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
-      env: { ...this.env, AKAN_WATCH: "1", ...(afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {}) },
+      env: {
+        ...this.env,
+        AKAN_WATCH: "1",
+        ...(afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {}),
+        ...(this.#patcherOff ? { AKAN_DEV_CSR_PATCHER: "off" } : {}),
+      },
       stdio: ["ignore", this.#stdio, this.#stdio],
       ipc: (msg: BuilderMessage) => {
         if (this.#proc !== proc) return;
@@ -151,6 +164,23 @@ export class IncrementalBuilderHost {
     }
     this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
   }
+  //? The resident builder patches the dev CSR bundle in its own process, so a bundler crash there takes the file watcher
+  //? with it. A builder that died holding the marker hands every later CSR save to build workers for this session;
+  //? a marker any other exit left behind (Ctrl-C mid-patch) is cleared so it cannot turn the patcher off next session.
+  #checkPatchingMarker(afterCrash: boolean): void {
+    const markers = [CSR_DEV_DIRNAME, SSR_DEV_DIRNAME]
+      .map((dirName) => path.join(this.app.cwdPath, ".akan/artifact", dirName, CSR_DEV_PATCHING_MARKER))
+      .filter((marker) => fs.existsSync(marker));
+    if (markers.length === 0) return;
+    if (afterCrash && !this.#patcherOff) {
+      this.#patcherOff = true;
+      this.logger.warn(
+        "the builder died while patching a dev module registry; registry saves go to a build worker until the next config or metadata restart (AKAN_DEV_CSR_PATCHER=off)",
+      );
+    }
+    for (const marker of markers) fs.rmSync(marker, { force: true });
+  }
+
   async #drain(stream: ReadableStream<Uint8Array> | undefined | null, kind: "stdout" | "stderr") {
     if (!stream) return;
     const decoder = new TextDecoder();

package/incrementalBuilder/incrementalBuilder.proc.test.ts

@@ -16,7 +16,7 @@ const until = async (proc: Bun.Subprocess, what: string, condition: () => boolea
 };
 
 describe("incremental builder process", () => {
-  test("says why and where a route's client bundle failed, in its answer, its build status and its log", async () => {
+  test("says why and where a route's client bundle failed, in its answer, its build status and its log, at the builder's generation", async () => {
     const { root } = track(await createTempApp("demo"));
     const appDir = path.join(root, "apps/demo");
     // The batch runner looks under the workspace root first: a stand-in for the boot build, which needs a whole app.
@@ -44,6 +44,7 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
         AKAN_PUBLIC_SERVE_DOMAIN: "localhost",
         AKAN_PUBLIC_ENV: "local",
         AKAN_WATCH: "0",
+        AKAN_BUILDER_INITIAL_GENERATION: "5",
       },
       stdio: ["ignore", "ignore", "pipe"],
       serialization: "advanced",
@@ -64,6 +65,8 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
       await until(proc, "build-route-res", () => messages.some((message) => message.type === "build-route-res"));
     } finally {
       proc.kill();
+      //? Windows refuses to remove a directory a live process has as its cwd.
+      await proc.exited;
     }
     const log = await new Response(proc.stderr).text();
 
@@ -74,8 +77,132 @@ process.send({ type: "build-batch-result", data: { generation, errors: {}, artif
       error: expect.stringContaining(reason),
     });
     expect(messages.find((message) => message.type === "build-status")).toMatchObject({
-      data: { generation: 3, phase: "route", ok: false, message: expect.stringContaining(reason) },
+      data: { generation: 6, phase: "route", ok: false, message: expect.stringContaining(reason) },
     });
     expect(log).toContain(reason);
   }, 30_000);
+
+  test("a killed boot build is tried again after the crash window, before boot-armed; a route build's check waits likewise", async () => {
+    // Inside the checkout so the route's client bundle resolves the framework from its source.
+    const { root } = track(await createTempApp("demo", path.join(import.meta.dir, "..", "local")));
+    const appDir = path.join(root, "apps/demo");
+    const runs = path.join(root, "ssr-runs.log");
+    // The first two registry builds are killed (the boot build and its retry), the third succeeds.
+    await writeText(
+      path.join(root, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      `import fs from "node:fs";
+const { generation, needs } = JSON.parse(process.argv[2]);
+if (needs.includes("ssr")) {
+  fs.appendFileSync(${JSON.stringify(runs)}, Date.now() + "\\n");
+  if (fs.readFileSync(${JSON.stringify(runs)}, "utf8").trim().split("\\n").length <= 2) process.exit(1);
+}
+process.send({ type: "build-batch-result", data: { generation, errors: {}, artifact: {}, optimizedFonts: { css: "", files: [] } } });
+`,
+    );
+    const page = path.join(appDir, "page/_index.tsx");
+    await writeText(page, 'import { Card } from "../ui/Card";\nexport default Card;\n');
+    await writeText(path.join(appDir, "ui/Card.tsx"), '"use client";\nexport const Card = () => null;\n');
+
+    const messages: BuilderMessage[] = [];
+    const proc = Bun.spawn(["bun", path.join(import.meta.dir, "incrementalBuilder.proc.ts")], {
+      cwd: appDir,
+      env: {
+        ...process.env,
+        AKAN_WORKSPACE_ROOT: root,
+        AKAN_PUBLIC_APP_NAME: "demo",
+        AKAN_PUBLIC_REPO_NAME: "repo",
+        AKAN_PUBLIC_SERVE_DOMAIN: "localhost",
+        AKAN_PUBLIC_ENV: "local",
+        AKAN_WATCH: "0",
+      },
+      stdio: ["ignore", "ignore", "ignore"],
+      serialization: "advanced",
+      ipc: (message: BuilderMessage) => {
+        messages.push(message);
+      },
+    });
+    const ssrRuns = async () =>
+      (await Bun.file(runs).exists()) ? (await Bun.file(runs).text()).trim().split("\n").map(Number) : [];
+    try {
+      await until(proc, "boot-armed", () => messages.some((message) => message.type === "boot-armed"));
+      const [first = 0, second = 0] = await ssrRuns();
+      expect(await ssrRuns()).toHaveLength(2);
+      expect(second - first).toBeGreaterThanOrEqual(9_500);
+      proc.send({
+        type: "build-route",
+        id: 1,
+        routeId: "page:/",
+        seeds: [page],
+        knownEntries: [],
+        generation: 3,
+      } satisfies BuilderReq);
+      await until(proc, "build-route-res", () => messages.some((message) => message.type === "build-route-res"));
+      expect(messages.find((message) => message.type === "build-route-res")).toMatchObject({ ok: true });
+      const deadline = Date.now() + 15_000;
+      while ((await ssrRuns()).length < 3 && Date.now() < deadline) await wait(100);
+      const [, retried = 0, third = 0] = await ssrRuns();
+      expect(third - retried).toBeGreaterThanOrEqual(9_500);
+    } finally {
+      proc.kill();
+      await proc.exited;
+    }
+  }, 60_000);
+
+  test("a route build's registry check that has nothing to add reports no ssr status, so it cannot hide a failure", async () => {
+    const { root } = track(await createTempApp("demo", path.join(import.meta.dir, "..", "local")));
+    const appDir = path.join(root, "apps/demo");
+    // The registry's own build is the real worker's; the rest is stood in for, as a boot build needs a whole app.
+    await writeText(
+      path.join(root, "pkgs/@akanjs/devkit/incrementalBuilder/buildBatch.proc.ts"),
+      `const { generation, needs } = JSON.parse(process.argv[2]);
+if (needs.includes("ssr")) await import(${JSON.stringify(path.join(import.meta.dir, "buildBatch.proc.ts"))});
+else process.send({ type: "build-batch-result", data: { generation, errors: {}, artifact: {}, optimizedFonts: { css: "", files: [] } } });
+`,
+    );
+    await writeText(path.join(appDir, "env/env.client.ts"), "export const env = {} as const;\n");
+    const page = path.join(appDir, "page/_index.tsx");
+    await writeText(page, 'import { Card } from "../ui/Card";\nexport default Card;\n');
+    await writeText(path.join(appDir, "ui/Card.tsx"), '"use client";\nexport const Card = () => null;\n');
+
+    const messages: BuilderMessage[] = [];
+    const proc = Bun.spawn(["bun", path.join(import.meta.dir, "incrementalBuilder.proc.ts")], {
+      cwd: appDir,
+      env: {
+        ...process.env,
+        AKAN_WORKSPACE_ROOT: root,
+        AKAN_PUBLIC_APP_NAME: "demo",
+        AKAN_PUBLIC_REPO_NAME: "repo",
+        AKAN_PUBLIC_SERVE_DOMAIN: "localhost",
+        AKAN_PUBLIC_ENV: "local",
+        AKAN_WATCH: "0",
+      },
+      stdio: ["ignore", "ignore", "ignore"],
+      serialization: "advanced",
+      ipc: (message: BuilderMessage) => {
+        messages.push(message);
+      },
+    });
+    const ssrStatuses = () =>
+      messages.filter((message) => message.type === "build-status" && message.data.phase === "ssr");
+    try {
+      await until(proc, "boot-armed", () => messages.some((message) => message.type === "boot-armed"));
+      expect(messages.some((message) => message.type === "ssr-updated")).toBe(true);
+      const before = ssrStatuses().length;
+      proc.send({
+        type: "build-route",
+        id: 1,
+        routeId: "page:/",
+        seeds: [page],
+        knownEntries: [],
+        generation: 3,
+      } satisfies BuilderReq);
+      await until(proc, "build-route-res", () => messages.some((message) => message.type === "build-route-res"));
+      expect(messages.find((message) => message.type === "build-route-res")).toMatchObject({ ok: true });
+      await wait(200);
+      expect(ssrStatuses().length).toBe(before);
+    } finally {
+      proc.kill();
+      await proc.exited;
+    }
+  }, 60_000);
 });