@akanjs/devkit 2.3.5 → 2.3.6-rc.1

package/frontendBuild/devChangePlanner.ts

@@ -0,0 +1,179 @@
+import path from "node:path";
+import type { ChangeKind, DevChangeAction, DevChangePlan, DevChangeRole } from "akanjs/server";
+
+const SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+const CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+const BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit"]);
+const CLIENT_SUFFIXES = [".Template.tsx", ".Unit.tsx", ".Util.tsx", ".View.tsx", ".Zone.tsx", ".store.ts"];
+const SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+const SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+const RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+
+export interface DevChangePlannerOptions {
+  workspaceRoot: string;
+}
+
+export interface DevChangePlanInput {
+  generation: number;
+  files: string[];
+  kinds: Iterable<Exclude<ChangeKind, "ignore">>;
+  generatedFiles?: string[];
+}
+
+export class DevChangePlanner {
+  readonly #workspaceRoot: string;
+
+  constructor({ workspaceRoot }: DevChangePlannerOptions) {
+    this.#workspaceRoot = path.resolve(workspaceRoot);
+  }
+
+  plan({ generation, files, kinds, generatedFiles = [] }: DevChangePlanInput): DevChangePlan {
+    const fileList = uniqueResolved([...files, ...generatedFiles]);
+    const generatedSet = new Set(generatedFiles.map((file) => path.resolve(file)));
+    const kindSet = new Set(kinds);
+    const roles = new Set<DevChangeRole>();
+    const actions = new Set<DevChangeAction>();
+    const reasonByFile: Record<string, string[]> = {};
+
+    for (const kind of kindSet) {
+      if (kind === "css") {
+        roles.add("css");
+        actions.add("rebuild-css");
+      }
+      if (kind === "config") {
+        roles.add("config");
+        actions.add("restart-dev-host");
+      }
+    }
+
+    for (const file of fileList) {
+      const reasons = new Set<string>();
+      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path.resolve(file)), reasons });
+      for (const role of fileRoles) roles.add(role);
+      if (reasons.has("runtime-metadata")) actions.add("restart-builder");
+      if (reasons.size > 0) reasonByFile[path.resolve(file)] = [...reasons].sort();
+    }
+
+    if (roles.has("barrel")) actions.add("sync-generated");
+    if (roles.has("server") || roles.has("shared")) actions.add("restart-backend");
+    if (roles.has("client") || roles.has("shared")) actions.add("rebuild-client");
+    if (roles.has("css")) actions.add("rebuild-css");
+
+    return {
+      generation,
+      files: fileList,
+      generatedFiles: uniqueResolved(generatedFiles),
+      roles: [...roles].sort(),
+      actions: [...actions].sort(),
+      reasonByFile,
+    };
+  }
+
+  #rolesForFile(
+    file: string,
+    { isGenerated, reasons }: { isGenerated: boolean; reasons: Set<string> },
+  ): Set<DevChangeRole> {
+    const roles = new Set<DevChangeRole>();
+    const abs = path.resolve(file);
+    const base = path.basename(abs);
+    const ext = path.extname(abs).toLowerCase();
+    const isSource = SOURCE_EXTS.has(ext);
+    const rel = path.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path.sep).filter(Boolean);
+
+    if (CONFIG_BASENAMES.has(base)) {
+      roles.add("config");
+      reasons.add("config-file");
+    }
+    if (ext === ".css") {
+      roles.add("css");
+      reasons.add("css-file");
+    }
+    if (isGenerated || (isSource && this.#isBarrelFacetChild(parts))) {
+      roles.add("barrel");
+      reasons.add(isGenerated ? "generated-index" : "barrel-facet-child");
+    }
+    if (isSource && this.#isServerBiased(abs, parts)) {
+      roles.add("server");
+      reasons.add("server-path");
+    }
+    if (isSource && this.#isClientBiased(abs, parts)) {
+      roles.add("client");
+      reasons.add("client-path");
+    }
+    if (isSource && this.#isSharedBiased(abs, parts)) {
+      roles.add("shared");
+      reasons.add("shared-path");
+    }
+    if (isSource && this.#isRuntimeMetadataFile(parts, base)) {
+      reasons.add("runtime-metadata");
+    }
+
+    if (roles.has("server") && roles.has("client")) {
+      roles.delete("server");
+      roles.delete("client");
+      roles.add("shared");
+      reasons.add("server-client-overlap");
+    }
+    if (roles.size === 0 && SOURCE_EXTS.has(ext) && this.#isWorkspaceSource(rel)) {
+      roles.add("shared");
+      reasons.add("workspace-source-fallback");
+    }
+
+    return roles;
+  }
+
+  #isServerBiased(abs: string, parts: string[]): boolean {
+    const base = path.basename(abs);
+    return (
+      parts.includes("srvkit") ||
+      SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) ||
+      base === "main.ts" ||
+      base === "server.ts"
+    );
+  }
+
+  #isClientBiased(abs: string, parts: string[]): boolean {
+    const base = path.basename(abs);
+    return (
+      parts.includes("ui") ||
+      parts.includes("webkit") ||
+      parts.includes("page") ||
+      CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix))
+    );
+  }
+
+  #isSharedBiased(abs: string, parts: string[]): boolean {
+    const base = path.basename(abs);
+    return (
+      parts.includes("common") ||
+      SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) ||
+      RUNTIME_METADATA_BASENAMES.has(base)
+    );
+  }
+
+  #isRuntimeMetadataFile(parts: string[], base: string): boolean {
+    const parent = parts.at(-2);
+    if (parent === "lib" && RUNTIME_METADATA_BASENAMES.has(base)) return true;
+    const libIndex = parts.lastIndexOf("lib");
+    if (libIndex < 0 || parts.length <= libIndex + 1) return false;
+    return base.endsWith(".dictionary.ts") || base.endsWith(".signal.ts");
+  }
+
+  #isBarrelFacetChild(parts: string[]): boolean {
+    if (parts.length < 4) return false;
+    const [scope, , facet, child] = parts;
+    if (scope !== "apps" && scope !== "libs") return false;
+    if (!facet || !BARREL_FACETS.has(facet)) return false;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx") return false;
+    return true;
+  }
+
+  #isWorkspaceSource(rel: string): boolean {
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) return false;
+    const [scope] = rel.split(path.sep);
+    return scope === "apps" || scope === "libs" || scope === "pkgs";
+  }
+}
+
+const uniqueResolved = (files: string[]) => [...new Set(files.map((file) => path.resolve(file)))].sort();

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,113 @@ 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"]);
+  });
+
+  test("recycles builder for macro-backed dictionary and signal metadata changes", () => {
+    const root = "/repo";
+    const planner = new DevChangePlanner({ workspaceRoot: root });
+    const dictionaryPlan = planner.plan({
+      generation: 3,
+      files: [`${root}/apps/demo/lib/_demo/demo.dictionary.ts`],
+      kinds: ["code"],
+    });
+    const signalPlan = planner.plan({
+      generation: 4,
+      files: [`${root}/libs/shared/lib/admin/admin.signal.ts`],
+      kinds: ["code"],
+    });
+
+    expect(dictionaryPlan.actions).toEqual(["rebuild-client", "restart-backend", "restart-builder"]);
+    expect(dictionaryPlan.reasonByFile[`${root}/apps/demo/lib/_demo/demo.dictionary.ts`]).toContain(
+      "runtime-metadata",
+    );
+    expect(signalPlan.actions).toContain("restart-builder");
+  });
+});
+
 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;