@akanjs/devkit 2.3.5 → 2.3.6-rc.0

package/frontendBuild/devGeneratedIndexSync.ts

@@ -0,0 +1,157 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+const BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit"]);
+const FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
+const FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
+const MODULE_UI_TYPES = ["Template", "Unit", "Util", "View", "Zone"] as const;
+const SERVICE_UI_TYPES = ["Util", "Zone"] as const;
+const SCALAR_UI_TYPES = ["Template", "Unit"] as const;
+
+export interface GeneratedIndexSyncResult {
+  changedFiles: string[];
+  errors: string[];
+}
+
+export interface DevGeneratedIndexSyncOptions {
+  workspaceRoot: string;
+}
+
+export class DevGeneratedIndexSync {
+  readonly #workspaceRoot: string;
+
+  constructor({ workspaceRoot }: DevGeneratedIndexSyncOptions) {
+    this.#workspaceRoot = path.resolve(workspaceRoot);
+  }
+
+  async syncForBatch(files: string[]): Promise<GeneratedIndexSyncResult> {
+    const indexPaths = new Set<string>();
+    const errors: string[] = [];
+
+    for (const file of files) {
+      const facetIndex = this.#facetIndexFor(file);
+      if (facetIndex) indexPaths.add(facetIndex);
+      const moduleIndex = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
+        errors.push(`[generated-index] module detection failed for ${file}: ${formatError(err)}`);
+        return null;
+      });
+      if (moduleIndex) indexPaths.add(moduleIndex);
+    }
+
+    const changedFiles: string[] = [];
+    for (const indexPath of [...indexPaths].sort()) {
+      try {
+        const changed = await this.#syncIndex(indexPath);
+        if (changed) changedFiles.push(indexPath);
+      } catch (err) {
+        errors.push(`[generated-index] sync failed for ${indexPath}: ${formatError(err)}`);
+      }
+    }
+
+    return { changedFiles, errors };
+  }
+
+  #facetIndexFor(file: string): string | null {
+    const abs = path.resolve(file);
+    const rel = path.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+    const parts = rel.split(path.sep).filter(Boolean);
+    if (parts.length < 4) return null;
+    const [scope, project, facet, child] = parts;
+    if ((scope !== "apps" && scope !== "libs") || !project || !facet || !BARREL_FACETS.has(facet)) return null;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx") return null;
+    return path.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+  }
+
+  async #moduleIndexForDirectoryEvent(file: string): Promise<string | null> {
+    const abs = path.resolve(file);
+    const rel = path.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+    const parts = rel.split(path.sep).filter(Boolean);
+    if (parts.length !== 4 && parts.length !== 5) return null;
+    const [scope, project, libSegment, moduleSegment, scalarSegment] = parts;
+    if ((scope !== "apps" && scope !== "libs") || !project || libSegment !== "lib") return null;
+
+    const isExistingDirectory = await stat(abs)
+      .then((s) => s.isDirectory())
+      .catch(() => false);
+    const looksLikeDeletedDirectory = !path.extname(abs);
+    if (!isExistingDirectory && !looksLikeDeletedDirectory) return null;
+
+    if (moduleSegment === "__scalar" && scalarSegment) {
+      return path.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+    }
+    if (!moduleSegment || moduleSegment === "__scalar") return null;
+    return path.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+  }
+
+  async #syncIndex(indexPath: string): Promise<boolean> {
+    const dir = path.dirname(indexPath);
+    const content = await this.#contentForIndex(indexPath);
+    if (content === null) {
+      if (!(await exists(indexPath))) return false;
+      await rm(indexPath, { force: true });
+      return true;
+    }
+
+    const current = await readFile(indexPath, "utf8").catch(() => null);
+    if (current === content) return false;
+    await mkdir(dir, { recursive: true });
+    await writeFile(indexPath, content);
+    return true;
+  }
+
+  async #contentForIndex(indexPath: string): Promise<string | null> {
+    const parts = path.relative(this.#workspaceRoot, indexPath).split(path.sep).filter(Boolean);
+    const facet = parts.at(-2);
+    if (facet && BARREL_FACETS.has(facet)) return this.#facetContent(path.dirname(indexPath));
+    return this.#moduleContent(path.dirname(indexPath));
+  }
+
+  async #facetContent(dir: string): Promise<string | null> {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const exportNames = entries
+      .flatMap((entry) => {
+        const name = entry.name;
+        if (name.startsWith(".")) return [];
+        if (entry.isDirectory()) return [name];
+        if (!entry.isFile()) return [];
+        if (!FACET_SOURCE_FILE_RE.test(name) || FACET_EXCLUDED_FILE_RE.test(name)) return [];
+        return [name.replace(FACET_SOURCE_FILE_RE, "")];
+      })
+      .sort();
+    if (exportNames.length === 0) return null;
+    return `${exportNames.map((name) => `export * from "./${name}";`).join("\n")}\n`;
+  }
+
+  async #moduleContent(dir: string): Promise<string | null> {
+    const rel = path.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path.sep).filter(Boolean);
+    const moduleSegment = parts.at(-1);
+    if (!moduleSegment) return null;
+    const isScalar = parts.at(-2) === "__scalar";
+    const rawModel = moduleSegment.startsWith("_") ? moduleSegment.slice(1) : moduleSegment;
+    if (!rawModel) return null;
+    const modelName = capitalize(rawModel);
+    const allowedTypes = isScalar
+      ? SCALAR_UI_TYPES
+      : moduleSegment.startsWith("_")
+        ? SERVICE_UI_TYPES
+        : MODULE_UI_TYPES;
+    const fileTypes: string[] = [];
+    for (const type of allowedTypes) {
+      if (await exists(path.join(dir, `${modelName}.${type}.tsx`))) fileTypes.push(type);
+    }
+    if (fileTypes.length === 0) return null;
+    return `\n${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).join("\n")}\n\nexport const ${modelName} = { ${fileTypes.join(", ")} };`;
+  }
+}
+
+const exists = async (file: string) =>
+  stat(file)
+    .then(() => true)
+    .catch(() => false);
+
+const capitalize = (value: string) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+
+const formatError = (err: unknown) => (err instanceof Error ? err.message : String(err));

package/frontendBuild/frontendBuild.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -7,6 +7,8 @@ import type { RoutesManifest } from "akanjs/server";
 import { CsrArtifactBuilder } from "./csrArtifactBuilder";
 import { CssCompiler, isIgnoredNodeModuleSource } from "./cssCompiler";
 import { CssImportResolver } from "./cssImportResolver";
+import { DevChangePlanner } from "./devChangePlanner";
+import { DevGeneratedIndexSync } from "./devGeneratedIndexSync";
 import { HmrChangeClassifier } from "./hmrChangeClassifier";
 import { PagesBundleBuilder } from "./pagesBundleBuilder";
 import { PagesEntrySourceGenerator } from "./pagesEntrySourceGenerator";
@@ -252,6 +254,92 @@ describe("HmrChangeClassifier", () => {
   });
 });
 
+describe("DevGeneratedIndexSync", () => {
+  test("updates barrel facet index for file add and delete", async () => {
+    const root = await makeTempRoot();
+    const foo = path.join(root, "libs/shared/common/foo.ts");
+    const index = path.join(root, "libs/shared/common/index.ts");
+    const sync = new DevGeneratedIndexSync({ workspaceRoot: root });
+
+    await write(foo, "export const foo = 1;\n");
+    const added = await sync.syncForBatch([foo]);
+
+    expect(added.errors).toEqual([]);
+    expect(added.changedFiles).toEqual([index]);
+    expect(await readFile(index, "utf8")).toBe('export * from "./foo";\n');
+
+    await rm(foo);
+    const removed = await sync.syncForBatch([foo]);
+
+    expect(removed.errors).toEqual([]);
+    expect(removed.changedFiles).toEqual([index]);
+    expect(await Bun.file(index).exists()).toBe(false);
+  });
+
+  test("ignores server/client folders as barrel facets", async () => {
+    const root = await makeTempRoot();
+    const serverFile = path.join(root, "libs/shared/server/foo.ts");
+    const clientFile = path.join(root, "libs/shared/client/foo.ts");
+    const sync = new DevGeneratedIndexSync({ workspaceRoot: root });
+
+    await write(serverFile, "export const foo = 1;\n");
+    await write(clientFile, "export const foo = 1;\n");
+    const result = await sync.syncForBatch([serverFile, clientFile]);
+
+    expect(result.errors).toEqual([]);
+    expect(result.changedFiles).toEqual([]);
+  });
+
+  test("ignores individual module UI file changes for module index sync", async () => {
+    const root = await makeTempRoot();
+    const template = path.join(root, "libs/shared/lib/admin/Admin.Template.tsx");
+    const sync = new DevGeneratedIndexSync({ workspaceRoot: root });
+
+    await write(template, "export const Admin = () => null;\n");
+    const result = await sync.syncForBatch([template]);
+
+    expect(result.errors).toEqual([]);
+    expect(result.changedFiles).toEqual([]);
+  });
+});
+
+describe("DevChangePlanner", () => {
+  test("classifies server, client, shared, and generated barrel changes", () => {
+    const root = "/repo";
+    const planner = new DevChangePlanner({ workspaceRoot: root });
+    const generatedIndex = `${root}/libs/shared/common/index.ts`;
+    const plan = planner.plan({
+      generation: 7,
+      files: [
+        `${root}/libs/shared/lib/admin/admin.service.ts`,
+        `${root}/libs/shared/lib/admin/Admin.Template.tsx`,
+        `${root}/libs/shared/lib/admin/admin.constant.ts`,
+        `${root}/libs/shared/common/foo.ts`,
+      ],
+      kinds: ["code"],
+      generatedFiles: [generatedIndex],
+    });
+
+    expect(plan.generatedFiles).toEqual([generatedIndex]);
+    expect(plan.files).toContain(generatedIndex);
+    expect(plan.roles).toEqual(["barrel", "client", "server", "shared"]);
+    expect(plan.actions).toEqual(["rebuild-client", "restart-backend", "sync-generated"]);
+    expect(plan.reasonByFile[generatedIndex]).toContain("generated-index");
+  });
+
+  test("keeps css-only and config changes separate from backend restarts", () => {
+    const root = "/repo";
+    const planner = new DevChangePlanner({ workspaceRoot: root });
+
+    expect(
+      planner.plan({ generation: 1, files: [`${root}/apps/akan/page/style.css`], kinds: ["css"] }).actions,
+    ).toEqual(["rebuild-css"]);
+    expect(
+      planner.plan({ generation: 2, files: [`${root}/apps/akan/akan.config.ts`], kinds: ["config"] }).actions,
+    ).toEqual(["restart-dev-host"]);
+  });
+});
+
 describe("CssImportResolver", () => {
   test("identifies package names and css files", () => {
     expect(CssImportResolver.getPackageName("@scope/pkg/button")).toBe("@scope/pkg");

package/frontendBuild/index.ts

@@ -5,6 +5,8 @@ export * from "./clientEntryDiscovery";
 export * from "./csrArtifactBuilder";
 export * from "./cssCompiler";
 export * from "./cssImportResolver";
+export * from "./devChangePlanner";
+export * from "./devGeneratedIndexSync";
 export * from "./fontOptimizer";
 export * from "./hmrChangeClassifier";
 export * from "./hmrWatcher";

package/incrementalBuilder/devWatchBatch.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { DevChangePlanner } from "../frontendBuild";
+import { prepareDevWatchBatch } from "./devWatchBatch";
+
+describe("prepareDevWatchBatch", () => {
+  test("includes generated indexes in the same invalidate generation", () => {
+    const root = "/repo";
+    const changedFile = `${root}/libs/shared/common/foo.ts`;
+    const generatedIndex = `${root}/libs/shared/common/index.ts`;
+    const prepared = prepareDevWatchBatch({
+      generation: 12,
+      batch: { files: [changedFile], kinds: new Set(["code"]) },
+      indexSync: { changedFiles: [generatedIndex], errors: [] },
+      changePlanner: new DevChangePlanner({ workspaceRoot: root }),
+    });
+
+    expect(prepared.hasSyncErrors).toBe(false);
+    expect(prepared.files).toEqual([changedFile, generatedIndex]);
+    expect(prepared.event.generation).toBe(12);
+    expect(prepared.event.files).toEqual(prepared.files);
+    expect(prepared.event.devPlan?.generatedFiles).toEqual([generatedIndex]);
+    expect(prepared.event.devPlan?.files).toEqual(prepared.files);
+  });
+
+  test.each([
+    "common",
+    "srvkit",
+    "ui",
+    "webkit",
+  ])("keeps %s facet add/delete generated index in the same generation", (facet) => {
+    const root = "/repo";
+    const changedFile = `${root}/libs/shared/${facet}/tmpExample.ts`;
+    const generatedIndex = `${root}/libs/shared/${facet}/index.ts`;
+    const prepared = prepareDevWatchBatch({
+      generation: 20,
+      batch: { files: [changedFile], kinds: new Set(["code"]) },
+      indexSync: { changedFiles: [generatedIndex], errors: [] },
+      changePlanner: new DevChangePlanner({ workspaceRoot: root }),
+    });
+
+    expect(new Set(prepared.files)).toEqual(new Set([changedFile, generatedIndex]));
+    expect(prepared.event.devPlan?.generatedFiles).toEqual([generatedIndex]);
+    expect(prepared.event.devPlan?.roles).toContain("barrel");
+    expect(prepared.event.devPlan?.actions).toContain("sync-generated");
+  });
+
+  test("marks failed generated index sync as an error generation", () => {
+    const root = "/repo";
+    const prepared = prepareDevWatchBatch({
+      generation: 13,
+      batch: { files: [`${root}/libs/shared/common/foo.ts`], kinds: new Set(["code"]) },
+      indexSync: { changedFiles: [], errors: ["sync failed"] },
+      changePlanner: new DevChangePlanner({ workspaceRoot: root }),
+    });
+
+    expect(prepared.hasSyncErrors).toBe(true);
+    expect(prepared.event.devPlan?.actions).toContain("report-error");
+  });
+});

package/incrementalBuilder/devWatchBatch.ts

@@ -0,0 +1,48 @@
+import type { BuilderEvent, ChangeBatch } from "akanjs/server";
+import type { DevChangePlanner, GeneratedIndexSyncResult } from "../frontendBuild";
+
+export interface PrepareDevWatchBatchOptions {
+  generation: number;
+  batch: ChangeBatch;
+  indexSync: GeneratedIndexSyncResult;
+  changePlanner: DevChangePlanner;
+}
+
+export interface PreparedDevWatchBatch {
+  files: string[];
+  kinds: ("code" | "css" | "config")[];
+  expandedBatch: ChangeBatch;
+  event: Extract<BuilderEvent, { type: "invalidate" }>;
+  hasSyncErrors: boolean;
+}
+
+export const prepareDevWatchBatch = ({
+  generation,
+  batch,
+  indexSync,
+  changePlanner,
+}: PrepareDevWatchBatchOptions): PreparedDevWatchBatch => {
+  const files = [...new Set([...batch.files, ...indexSync.changedFiles])].sort();
+  const kindSet = new Set(batch.kinds);
+  if (indexSync.changedFiles.length > 0) kindSet.add("code");
+  const kinds = [...kindSet] as ("code" | "css" | "config")[];
+  const expandedBatch: ChangeBatch = { files, kinds: kindSet };
+  const devPlan = changePlanner.plan({
+    generation,
+    files,
+    kinds,
+    generatedFiles: indexSync.changedFiles,
+  });
+
+  if (indexSync.errors.length > 0 && !devPlan.actions.includes("report-error")) {
+    devPlan.actions = [...devPlan.actions, "report-error"].sort();
+  }
+
+  return {
+    files,
+    kinds,
+    expandedBatch,
+    event: { type: "invalidate", kinds, files, generation, devPlan },
+    hasSyncErrors: indexSync.errors.length > 0,
+  };
+};

package/incrementalBuilder/incrementalBuilder.host.ts

@@ -9,6 +9,7 @@ const builderMsgTypeSet = new Set<BuilderMessage["type"]>([
   "invalidate",
   "css-updated",
   "pages-updated",
+  "build-status",
 ]);
 interface IncrementalBuilderHostOptions {
   app: App;

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -6,6 +6,8 @@ import {
   type ClientEntryDiscovery,
   CsrArtifactBuilder,
   type CssCompiler,
+  DevChangePlanner,
+  DevGeneratedIndexSync,
   FontOptimizer,
   GraphClientEntryDiscovery,
   HmrWatcher,
@@ -18,12 +20,13 @@ import {
 import { Logger } from "akanjs/common";
 import type {
   BaseBuildArtifact,
-  BuilderEvent,
   BuilderMessage,
   BuilderReq,
   BuilderRes,
+  BuildPhase,
   BuildRouteResultPayload,
 } from "akanjs/server";
+import { prepareDevWatchBatch } from "./devWatchBatch";
 
 interface IncrementalBuilderOptions {
   app: App;
@@ -42,6 +45,8 @@ class IncrementalBuilder {
   #cssCompiler: CssCompiler;
   #optimizedFonts: Awaited<ReturnType<FontOptimizer["optimize"]>>;
   #discovery: ClientEntryDiscovery;
+  #changePlanner: DevChangePlanner;
+  #generatedIndexSync: DevGeneratedIndexSync;
   #generation = 0;
   #workQueue: Promise<void> = Promise.resolve();
   #cssRebuildQueue: Promise<void> = Promise.resolve();
@@ -55,6 +60,8 @@ class IncrementalBuilder {
     this.#cssCompiler = options.cssCompiler;
     this.#optimizedFonts = options.optimizedFonts;
     this.#discovery = options.discovery;
+    this.#changePlanner = new DevChangePlanner({ workspaceRoot: options.app.workspace.workspaceRoot });
+    this.#generatedIndexSync = new DevGeneratedIndexSync({ workspaceRoot: options.app.workspace.workspaceRoot });
   }
 
   async handleBuildRoute(msg: BuilderReq): Promise<BuilderRes> {
@@ -72,6 +79,7 @@ class IncrementalBuilder {
         discovery: this.#discovery,
       }).build();
       this.#logger.verbose(`build-route ok routeId=${msg.routeId} newEntries=${delta.newEntries.length}`);
+      this.#sendBuildStatus("route", { generation: msg.generation, ok: true, files: msg.seeds });
       return {
         type: "build-route-res",
         id: msg.id,
@@ -90,9 +98,26 @@ class IncrementalBuilder {
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       this.#logger.error(`build-route failed routeId=${msg.routeId}: ${errMsg}`);
+      this.#sendBuildStatus("route", { generation: msg.generation, ok: false, files: msg.seeds, message: errMsg });
       return { type: "build-route-res", id: msg.id, ok: false, error: errMsg };
     }
   }
+  #sendBuildStatus(
+    phase: BuildPhase,
+    { generation, ok, files, message }: { generation?: number; ok: boolean; files?: string[]; message?: string },
+  ): void {
+    if (typeof generation !== "number") return;
+    process.send?.({
+      type: "build-status",
+      data: {
+        generation,
+        phase,
+        ok,
+        files: files ?? [],
+        message,
+      },
+    });
+  }
   async #enqueueWork<T>(label: string, fn: () => Promise<T>): Promise<T> {
     const started = Date.now();
     const run = this.#workQueue.then(fn, fn);
@@ -191,10 +216,18 @@ class IncrementalBuilder {
             generation: next.generation,
             changedFiles: next.changedFiles,
           });
+          this.#sendBuildStatus("css", { generation: next.generation, ok: true, files: next.changedFiles });
           this.#logger.verbose(`css-rebuild checked (${Date.now() - started}ms)`);
         })
         .catch((err) => {
-          this.#logger.error(`css-rebuild failed: ${err instanceof Error ? err.message : err}`);
+          const message = err instanceof Error ? err.message : String(err);
+          this.#logger.error(`css-rebuild failed: ${message}`);
+          this.#sendBuildStatus("css", {
+            generation: next.generation,
+            ok: false,
+            files: next.changedFiles,
+            message,
+          });
         });
     }, 150);
   }
@@ -233,25 +266,43 @@ class IncrementalBuilder {
   }
 
   async #handleWatchBatch(appDir: string, artifactDir: string, batch: ChangeBatch) {
-    const kinds = [...batch.kinds] as ("code" | "css" | "config")[];
-    if (kinds.length === 0) return;
+    const rawKinds = new Set(batch.kinds);
+    if (rawKinds.size === 0) return;
     const generation = ++this.#generation;
-    this.#logger.verbose(`[hmr] batch generation=${generation} kinds=${kinds.join(",")} files=${batch.files.length}`);
+    const indexSync = await this.#generatedIndexSync.syncForBatch(batch.files);
+    const { files, kinds, expandedBatch, event, hasSyncErrors } = prepareDevWatchBatch({
+      generation,
+      batch,
+      indexSync,
+      changePlanner: this.#changePlanner,
+    });
+    const devPlan = event.devPlan;
+    this.#logger.verbose(
+      `[hmr] batch generation=${generation} kinds=${kinds.join(",")} files=${files.length} generated=${indexSync.changedFiles.length} roles=${devPlan.roles.join(",") || "(none)"} actions=${devPlan.actions.join(",") || "(none)"}`,
+    );
+    for (const error of indexSync.errors) this.#logger.error(error);
 
     if (kinds.includes("code")) {
       const started = Date.now();
       if (kinds.includes("config")) this.#discovery = await GraphClientEntryDiscovery.create(this.#app);
-      else this.#discovery.invalidate?.(batch.files);
+      else this.#discovery.invalidate?.(files);
       this.#logger.verbose(
         `client-entry-discovery ${kinds.includes("config") ? "refreshed" : "invalidated"} (${Date.now() - started}ms)`,
       );
     }
 
-    if (kinds.includes("code") && (await this.batchMayChangePageKeys(appDir, batch))) {
+    if (hasSyncErrors) {
+      this.#sendBuildStatus("barrel", { generation, ok: false, files, message: indexSync.errors.join("\n") });
+      process.send?.(event);
+      return;
+    }
+    if (indexSync.changedFiles.length > 0) this.#sendBuildStatus("barrel", { generation, ok: true, files });
+
+    if (kinds.includes("code") && (await this.batchMayChangePageKeys(appDir, expandedBatch))) {
       const started = Date.now();
       await this.#app.getPageKeys({ refresh: true });
       this.#logger.verbose(`pageKeys updated, app pageKeys are refreshed (${Date.now() - started}ms)`);
-    } else if (kinds.includes("code") && this.batchTouchesPagesTree(appDir, batch)) {
+    } else if (kinds.includes("code") && this.batchTouchesPagesTree(appDir, expandedBatch)) {
       this.#logger.verbose("pageKeys refresh skipped; changed page source cannot add/remove a route key");
     }
 
@@ -259,15 +310,17 @@ class IncrementalBuilder {
       try {
         const started = Date.now();
         await new CsrArtifactBuilder(this.#app).build();
+        this.#sendBuildStatus("csr", { generation, ok: true, files });
         this.#logger.verbose(`csr-rebundle ok (${Date.now() - started}ms)`);
       } catch (err) {
-        this.#logger.error(`csr-rebundle failed: ${err instanceof Error ? err.message : err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        this.#logger.error(`csr-rebundle failed: ${message}`);
+        this.#sendBuildStatus("csr", { generation, ok: false, files, message });
       }
     } else if (kinds.includes("code")) {
       this.#logger.verbose(`csr-rebundle skipped; set AKAN_DEV_CSR_REBUILD=1 to enable per-save CSR rebuilds`);
     }
 
-    const event: BuilderEvent = { type: "invalidate", kinds, files: batch.files, generation };
     process.send?.(event);
 
     if (kinds.includes("code")) {
@@ -276,15 +329,18 @@ class IncrementalBuilder {
         const next = await new PagesBundleBuilder(this.#app).build();
         process.send?.({
           type: "pages-updated",
-          data: { bundlePath: next.bundlePath, buildId: next.buildId, generation, changedFiles: batch.files },
+          data: { bundlePath: next.bundlePath, buildId: next.buildId, generation, changedFiles: files },
         });
+        this.#sendBuildStatus("pages", { generation, ok: true, files });
         this.#logger.verbose(`pages-rebundle ok buildId=${next.buildId} (${Date.now() - started}ms)`);
       } catch (err) {
-        this.#logger.error(`pages-rebundle failed: ${err instanceof Error ? err.message : err}`);
+        const message = err instanceof Error ? err.message : String(err);
+        this.#logger.error(`pages-rebundle failed: ${message}`);
+        this.#sendBuildStatus("pages", { generation, ok: false, files, message });
       }
     }
     if (kinds.includes("code") || kinds.includes("css")) {
-      this.scheduleCssRebuild(artifactDir, { refresh: true, generation, changedFiles: batch.files });
+      this.scheduleCssRebuild(artifactDir, { refresh: true, generation, changedFiles: files });
       this.#logger.verbose(`css-rebuild scheduled generation=${generation}`);
     }
   }

package/incrementalBuilder/index.ts

@@ -1 +1,2 @@
+export * from "./devWatchBatch";
 export * from "./incrementalBuilder.host";