@akanjs/devkit 3.0.0-beta.9 → 3.0.0

package/incrementalBuilder/builderChannel.test.ts

@@ -1,30 +1,18 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
+import { describe, expect, test } from "bun:test";
 import path from "node:path";
+import { tempDirs } from "../testHelpers";
 import { BuilderChannel } from "./builderChannel";
 
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-  for (const dir of tempDirs.splice(0)) await rm(dir, { recursive: true, force: true });
-});
+const tempDir = tempDirs("builder-channel-");
 
 type SendMode = "drain" | "await" | "bare";
 
-/**
- * Run a child that sends what the builder sends and then exits the way the recycle drain does, and
- * report what the parent actually received.
- *
- * `payload` picks the message shape, because shape decides whether a bare send survives: `manifest` is a
- * map of many short strings (a `build-route-res` delta), `css` is one long string (a base64 stylesheet).
- */
+// Shape decides whether a bare send survives: `manifest` is many short strings, `css` one long string.
 const sendThenExit = async (
   bytes: number,
   { mode, payload }: { mode: SendMode; payload: "manifest" | "css" },
 ): Promise<Array<{ type?: string }>> => {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "builder-channel-"));
-  tempDirs.push(dir);
+  const dir = await tempDir();
   const entry = path.join(dir, "child.ts");
   const modulePath = JSON.stringify(path.join(import.meta.dir, "builderChannel"));
   const build =
@@ -63,44 +51,42 @@ const sendThenExit = async (
   return received;
 };
 
+const withDeferredFlushes = async (fn: (flushes: Array<() => void>) => Promise<void>) => {
+  const send = process.send;
+  const flushes: Array<() => void> = [];
+  try {
+    (process as { send?: unknown }).send = (_msg: unknown, _h: unknown, _o: unknown, cb: () => void) => {
+      flushes.push(cb);
+      return true;
+    };
+    await fn(flushes);
+  } finally {
+    (process as { send?: unknown }).send = send;
+  }
+};
+
 describe("BuilderChannel", () => {
   test("delivers a reply too large for the pipe buffer before the process exits", async () => {
     expect(await sendThenExit(1_000_000, { mode: "await", payload: "manifest" })).toMatchObject([{ id: 7 }]);
-    // A manifest delta is usually well past the buffer, but the small case must keep working too.
     expect(await sendThenExit(0, { mode: "await", payload: "manifest" })).toMatchObject([{ id: 7 }]);
   });
 
   test("a drained event survives the exit even though nobody awaited it", async () => {
-    // The event path: `css-updated` is relayed with no caller to await it, and the recycle drain exits
-    // milliseconds later. Only `drain()` stands between the two.
     expect(await sendThenExit(200_000, { mode: "drain", payload: "css" })).toMatchObject([{ type: "css-updated" }]);
   });
 
-  /**
-   * darwin only, measured: on Linux a 1MB message sent immediately before `process.exit` **arrives in
-   * full**, so the loss this control demonstrates does not reproduce there and the assertion would fail
-   * for the right reason on the wrong platform. `BuilderChannel` itself stays correct and costs nothing
-   * on Linux — the bug it prevents is one macOS developers hit and a Linux fleet does not.
-   */
+  // darwin only: on Linux a message sent right before `process.exit` arrives in full, so the loss does not reproduce.
   test.skipIf(process.platform !== "darwin")(
     "without the flush wait the same messages are lost, which is why this class exists",
     async () => {
       // Controls, not requirements: if a future bun flushes ipc writes on exit, these fail and say so.
       expect(await sendThenExit(1_000_000, { mode: "bare", payload: "manifest" })).toEqual([]);
-      // 20KB of css, far below the 64KB the manifest shape survives — one long string dies much earlier,
-      // so no size threshold would have been safe to special-case.
       expect(await sendThenExit(20_000, { mode: "bare", payload: "css" })).toEqual([]);
     },
   );
 
   test("drain resolves only once every tracked send has flushed", async () => {
-    const send = process.send;
-    const flushes: Array<() => void> = [];
-    try {
-      (process as { send?: unknown }).send = (_msg: unknown, _h: unknown, _o: unknown, cb: () => void) => {
-        flushes.push(cb);
-        return true;
-      };
+    await withDeferredFlushes(async (flushes) => {
       BuilderChannel.emit({ type: "builder-ready" });
       BuilderChannel.emit({ type: "builder-ready" });
       let drained = false;
@@ -113,31 +99,20 @@ describe("BuilderChannel", () => {
       expect(drained).toBe(false);
       flushes[1]?.();
       expect(await draining).toBe(2);
-    } finally {
-      (process as { send?: unknown }).send = send;
-    }
+    });
   });
 
   test("a send started while draining is drained too", async () => {
-    const send = process.send;
-    const flushes: Array<() => void> = [];
-    try {
-      (process as { send?: unknown }).send = (_msg: unknown, _h: unknown, _o: unknown, cb: () => void) => {
-        flushes.push(cb);
-        return true;
-      };
+    await withDeferredFlushes(async (flushes) => {
       BuilderChannel.emit({ type: "builder-ready" });
       const draining = BuilderChannel.drain();
-      // What `#reportMetrics` does from a work item's `finally`, after the drain has begun.
       BuilderChannel.emit({ type: "builder-metrics", data: { rssBytes: 1, generation: 1, workCount: 1 } });
       for (let i = 0; i < 4 && flushes.length; i++) {
         flushes.shift()?.();
         await Bun.sleep(1);
       }
       expect(await draining).toBe(2);
-    } finally {
-      (process as { send?: unknown }).send = send;
-    }
+    });
   });
 
   test("resolves instead of hanging when there is no ipc channel", async () => {

package/incrementalBuilder/builderChannel.ts

@@ -1,42 +1,18 @@
 import type { BuilderMessage } from "akanjs/server";
 
-/**
- * Every message the builder sends its host, and the record of which of those writes have actually left
- * the process.
- *
- * `process.exit` discards an ipc write that has not flushed, and this process exits routinely — the
- * recycle that keeps its RSS under the ceiling ends in `process.exit(0)`. Whether a given message
- * survives that depends on its *shape*, not only its size. Measured on bun 1.3.14 (darwin,
- * `serialization: "advanced"`), send-then-exit-immediately, 20 rounds each:
- *
- * - one long string: 8KB delivered 20/20, 16KB delivered **0/20**
- * - many short strings: 60KB delivered 20/20, 100KB delivered **0/20**
- *
- * `css-updated` is the first shape (a base64 stylesheet per url) and `build-route-res` the second (a
- * manifest delta), so neither sits safely under a threshold worth relying on. Nothing here assumes one:
- * every send reports when it flushed, and `drain` is what `shutdown` awaits before exiting.
- *
- * A natural exit does *not* have this problem — a process that simply returns from `main` flushes 1MB
- * 20/20 — which is why the disposable build worker needs none of this. Only an explicit `process.exit`
- * cuts a write short.
- */
+// `process.exit` drops an ipc write that has not flushed (a natural exit does not), and whether one survives
+// depends on the message's shape as well as its size — so every send reports its flush and `shutdown` drains.
 export class BuilderChannel {
-  /**
-   * Bound so a runtime that ever stops invoking the flush callback costs one late message instead of
-   * wedging the shutdown drain until the host's kill watchdog fires.
-   */
+  // Bounded so a runtime that never calls the flush callback costs one late message, not a wedged drain.
   static readonly #flushTimeoutMs = 5_000;
-  /** Sends that have not flushed yet; `drain` only ever needs to await them all. */
   static readonly #flushing = new Set<Promise<void>>();
 
-  /** Send, and resolve once the write has left this process. */
   static send(message: BuilderMessage): Promise<void> {
     const send = process.send;
     if (!send) return Promise.resolve();
     const flushed = new Promise<void>((resolve) => {
       const timer = setTimeout(resolve, BuilderChannel.#flushTimeoutMs);
-      // A failed send has nothing to retry: the host answers an unanswered request id itself when this
-      // process exits, and a lost event is superseded by the next generation's.
+      // No retry: the host answers an orphaned request id on exit, and a lost event is superseded next generation.
       send.call(process, message, undefined, undefined, () => {
         clearTimeout(timer);
         resolve();
@@ -47,19 +23,12 @@ export class BuilderChannel {
     return flushed;
   }
 
-  /**
-   * Send an event no caller awaits. Tracked exactly like `send`, which is the whole point: a relayed
-   * `css-updated` has nobody to await it, so `drain` is the only thing standing between it and the exit.
-   */
+  // Tracked like `send`: for an event nobody awaits, `drain` is all that stands between it and the exit.
   static emit(message: BuilderMessage): void {
     void BuilderChannel.send(message);
   }
 
-  /**
-   * Resolve once every send handed over so far has flushed, and report how many were still in flight.
-   * Sends started *while* draining are covered too — `#reportMetrics` can fire from a work item's
-   * `finally`, after the drain has already begun.
-   */
+  // Loops because `#reportMetrics` can send from a work item's `finally` after the drain has begun.
   static async drain(): Promise<number> {
     let flushed = 0;
     while (BuilderChannel.#flushing.size) {

package/incrementalBuilder/builderRequestRouter.test.ts

@@ -10,7 +10,6 @@ const routeReq = (id: number, routeId: string): BuilderReq => ({
   knownEntries: [],
 });
 
-/** `routeId` is what tells one generation's answer from the other's; the rest is an empty delta. */
 const routeRes = (id: number, routeId: string): Extract<BuilderRes, { ok: true }> => ({
   type: "build-route-res",
   id,
@@ -23,7 +22,6 @@ describe("BuilderRequestRouter", () => {
     const router = new BuilderRequestRouter();
     router.startGeneration();
 
-    // Everything but the id travels untouched; the builder never learns it was renumbered.
     const first = router.issue(routeReq(1, "/home"));
     const second = router.issue(routeReq(2, "/about"));
     expect(first.routeId).toBe("/home");
@@ -35,11 +33,6 @@ describe("BuilderRequestRouter", () => {
     expect(router.inFlightCount).toBe(0);
   });
 
-  /**
-   * The defect this class exists for. `BuilderRpc` numbers from 1 in every backend process, so without
-   * renumbering the second generation's `id: 1` request is settled by the first generation's answer —
-   * a page rendered against another route's client manifest — and its own answer is then dropped.
-   */
   test("does not deliver a dead generation's answer to the backend that replaced it", () => {
     const router = new BuilderRequestRouter();
     router.startGeneration();
@@ -70,7 +63,6 @@ describe("BuilderRequestRouter", () => {
     router.startGeneration();
     const outgoing = router.issue(routeReq(4, "/home"));
 
-    // The caller answers the backend itself in this case, so a late builder answer must not answer it again.
     router.withdraw(outgoing.id);
     expect(router.inFlightCount).toBe(0);
     expect(router.settle(routeRes(outgoing.id, "/home"))).toBeNull();

package/incrementalBuilder/builderRequestRouter.ts

@@ -3,19 +3,8 @@ import type { BuilderCsrReq, BuilderCsrRes, BuilderReq, BuilderRes } from "akanj
 type BuilderRequest = BuilderReq | BuilderCsrReq;
 type BuilderResponse = BuilderRes | BuilderCsrRes;
 
-/**
- * Correlation ids for builder requests, renumbered by the dev host so they survive a backend restart.
- *
- * `BuilderRpc` numbers its requests from 1 in each backend *process*, and the host relays them to a
- * builder that outlives the backend. So after a restart the two generations collide on id 1: the builder
- * answers the request the *previous* backend made, the host relays it, and the new backend settles its own
- * request of that number with another route's manifest delta — a page rendered against client modules that
- * were never built for it. The answer it was actually waiting for then arrives to an empty pending map and
- * is dropped, so the correct build is discarded too.
- *
- * A host-owned id fixes it without touching the protocol: neither the backend nor the builder learns that
- * anything was renumbered, and a response whose generation is gone is discarded instead of misdelivered.
- */
+// `BuilderRpc` numbers from 1 per backend process while the builder outlives backends, so ids collide across a
+// restart; host-owned ids keep a dead generation's answer from settling the new backend's request.
 export class BuilderRequestRouter {
   #generation = 0;
   #nextId = 1;
@@ -29,33 +18,25 @@ export class BuilderRequestRouter {
     return this.#inFlight.size;
   }
 
-  /**
-   * Begin a new backend generation, abandoning every request the previous one owned.
-   *
-   * Nothing is answered on the way out: the process that asked is gone, and its `BuilderRpc` went with it.
-   */
+  // Abandons the previous generation's requests unanswered: the backend that asked is gone.
   startGeneration(): number {
     this.#generation += 1;
     this.#inFlight.clear();
     return this.#generation;
   }
 
-  /** The request to forward to the builder, carrying this host's id in place of the backend's. */
   issue<T extends BuilderRequest>(message: T): T {
     const id = this.#nextId++;
     this.#inFlight.set(id, { backendId: message.id, generation: this.#generation });
     return { ...message, id };
   }
 
-  /** Give an id back when the send failed, so the caller answers the backend itself. */
+  // For a failed send, after which the caller answers the backend itself.
   withdraw(id: number): void {
     this.#inFlight.delete(id);
   }
 
-  /**
-   * The response to forward to the backend with its own id restored, or `null` when no live backend is
-   * waiting for it — either it was never issued or the generation that issued it has been replaced.
-   */
+  // null when no live backend is waiting: never issued, or its generation was replaced.
   settle<T extends BuilderResponse>(message: T): T | null {
     const request = this.#inFlight.get(message.id);
     if (!request) return null;

package/incrementalBuilder/builderWorkQueue.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from "bun:test";
+import { type BatchJob, BuilderWorkQueue } from "./builderWorkQueue";
+
+const gate = () => {
+  const { promise: opened, resolve: open } = Promise.withResolvers<void>();
+  return { open, opened };
+};
+
+describe("BuilderWorkQueue", () => {
+  test("runs jobs one at a time, in the order they were queued", async () => {
+    const order: string[] = [];
+    const queue = new BuilderWorkQueue({ runBatch: async () => undefined });
+    const first = gate();
+    const a = queue.enqueue("a", async () => {
+      await first.opened;
+      order.push("a");
+    });
+    const b = queue.enqueue("b", async () => {
+      order.push("b");
+      return 2;
+    });
+    expect(queue.size).toBe(2);
+    first.open();
+    await a;
+    expect(await b).toBe(2);
+    expect(order).toEqual(["a", "b"]);
+    expect(queue.size).toBe(0);
+  });
+
+  test("folds a batch queued behind another batch into it, for the newest generation", async () => {
+    const ran: BatchJob[] = [];
+    const running = gate();
+    const queue = new BuilderWorkQueue({
+      runBatch: async (batch) => {
+        ran.push(batch);
+        if (ran.length === 1) await running.opened;
+      },
+    });
+    const first = queue.enqueueBatch({ generation: 1, needs: ["pages", "css"], changedFiles: ["a.tsx"] });
+    const second = queue.enqueueBatch({
+      generation: 2,
+      needs: ["pages", "css"],
+      changedFiles: ["b.tsx"],
+      discovery: { files: ["b.tsx"], refresh: false, generation: 2 },
+    });
+    const third = queue.enqueueBatch({ generation: 3, needs: ["csr", "pages"], changedFiles: ["a.tsx", "c.tsx"] });
+    expect(second).toBe(third);
+    running.open();
+    await Promise.all([first, second, third]);
+    expect(ran).toHaveLength(2);
+    expect(ran[1]).toEqual({
+      generation: 3,
+      needs: ["pages", "css", "csr"],
+      changedFiles: ["b.tsx", "a.tsx", "c.tsx"],
+      discovery: { files: ["b.tsx"], refresh: false, generation: 2 },
+    });
+  });
+
+  test("keeps a batch queued after a task behind that task", async () => {
+    const order: string[] = [];
+    const running = gate();
+    const queue = new BuilderWorkQueue({
+      runBatch: async (batch) => {
+        order.push(`batch:${batch.generation}`);
+        if (batch.generation === 1) await running.opened;
+      },
+    });
+    const first = queue.enqueueBatch({ generation: 1, needs: ["pages"], changedFiles: [] });
+    const route = queue.enqueue("route", async () => {
+      order.push("route");
+    });
+    const second = queue.enqueueBatch({ generation: 2, needs: ["pages"], changedFiles: [] });
+    running.open();
+    await Promise.all([first, route, second]);
+    expect(order).toEqual(["batch:1", "route", "batch:2"]);
+  });
+
+  test("drains jobs queued while it waits, and survives a job that throws", async () => {
+    const queue = new BuilderWorkQueue({ runBatch: async () => undefined });
+    const failing = queue.enqueue("fails", async () => {
+      throw new Error("boom");
+    });
+    let late = false;
+    void queue.enqueue("queues-more", async () => {
+      void queue.enqueue("late", async () => {
+        late = true;
+      });
+    });
+    await expect(failing).rejects.toThrow("boom");
+    await queue.drain();
+    expect(late).toBe(true);
+    expect(queue.size).toBe(0);
+  });
+});

package/incrementalBuilder/builderWorkQueue.ts

@@ -0,0 +1,126 @@
+import type { HmrTrace } from "akanjs/server";
+import type { BuildBatchNeed } from "./buildBatchProtocol";
+
+export interface DiscoveryJob {
+  files: string[];
+  refresh: boolean;
+  /** The newest batch these files came from: a route build that starts after has taken it in. */
+  generation: number;
+}
+
+export interface BatchJob {
+  generation: number;
+  needs: BuildBatchNeed[];
+  changedFiles: string[];
+  trace?: HmrTrace;
+  /** Code files whose client-entry discovery goes stale before this batch builds; `refresh` rebuilds it whole. */
+  discovery?: DiscoveryJob;
+}
+
+interface QueuedJob {
+  label: string;
+  batch: BatchJob | null;
+  run: () => Promise<void>;
+  settle: PromiseWithResolvers<void>;
+}
+
+export interface BuilderWorkQueueOptions {
+  runBatch: (batch: BatchJob) => Promise<void>;
+  onSettled?: (label: string, ms: number) => void;
+}
+
+//* The builder's slow lane: build-worker batches, route builds and full CSR builds run here one at a time, so a save's
+//* CSR patch never waits behind them. A batch queued behind another batch folds into it: a burst of saves builds pages
+//* and css once for the newest generation instead of once per save.
+export class BuilderWorkQueue {
+  readonly #runBatch: BuilderWorkQueueOptions["runBatch"];
+  readonly #onSettled: BuilderWorkQueueOptions["onSettled"];
+  readonly #pending: QueuedJob[] = [];
+  #running: QueuedJob | null = null;
+  #idle: Promise<void> = Promise.resolve();
+  #wakeIdle: (() => void) | null = null;
+
+  constructor({ runBatch, onSettled }: BuilderWorkQueueOptions) {
+    this.#runBatch = runBatch;
+    this.#onSettled = onSettled;
+  }
+
+  /** Jobs waiting or running. */
+  get size(): number {
+    return this.#pending.length + (this.#running ? 1 : 0);
+  }
+
+  enqueueBatch(batch: BatchJob): Promise<void> {
+    const tail = this.#pending.at(-1);
+    if (tail?.batch) {
+      tail.batch = BuilderWorkQueue.merge(tail.batch, batch);
+      return tail.settle.promise;
+    }
+    const job = this.#job("batch", batch, async () => undefined);
+    job.run = async () => await this.#runBatch(job.batch ?? batch);
+    return this.#push(job);
+  }
+
+  enqueue<T>(label: string, run: () => Promise<T>): Promise<T> {
+    let result: T | undefined;
+    const job = this.#job(label, null, async () => {
+      result = await run();
+    });
+    return this.#push(job).then(() => result as T);
+  }
+
+  /** Resolves once nothing is waiting or running, including jobs queued while it waits. */
+  async drain(): Promise<void> {
+    while (this.size > 0) await this.#idle;
+  }
+
+  static merge(into: BatchJob, next: BatchJob): BatchJob {
+    const discovery =
+      into.discovery || next.discovery
+        ? {
+            files: [...new Set([...(into.discovery?.files ?? []), ...(next.discovery?.files ?? [])])],
+            refresh: !!into.discovery?.refresh || !!next.discovery?.refresh,
+            generation: Math.max(into.discovery?.generation ?? 0, next.discovery?.generation ?? 0),
+          }
+        : undefined;
+    return {
+      generation: Math.max(into.generation, next.generation),
+      needs: [...new Set([...into.needs, ...next.needs])],
+      changedFiles: [...new Set([...into.changedFiles, ...next.changedFiles])],
+      trace: next.trace ?? into.trace,
+      ...(discovery ? { discovery } : {}),
+    };
+  }
+
+  #job(label: string, batch: BatchJob | null, run: () => Promise<void>): QueuedJob {
+    return { label, batch, run, settle: Promise.withResolvers<void>() };
+  }
+
+  #push(job: QueuedJob): Promise<void> {
+    if (this.size === 0)
+      this.#idle = new Promise<void>((resolve) => {
+        this.#wakeIdle = resolve;
+      });
+    this.#pending.push(job);
+    if (!this.#running) void this.#pump();
+    return job.settle.promise;
+  }
+
+  async #pump(): Promise<void> {
+    for (let job = this.#pending.shift(); job; job = this.#pending.shift()) {
+      this.#running = job;
+      const started = Date.now();
+      try {
+        await job.run();
+        job.settle.resolve();
+      } catch (error) {
+        job.settle.reject(error);
+      } finally {
+        this.#running = null;
+        this.#onSettled?.(job.label, Date.now() - started);
+      }
+    }
+    this.#wakeIdle?.();
+    this.#wakeIdle = null;
+  }
+}

package/incrementalBuilder/devWatchBatch.test.ts

@@ -1,18 +1,22 @@
 import { describe, expect, test } from "bun:test";
-import { DevChangePlanner } from "../frontendBuild";
+import path from "node:path";
+import { DevChangePlanner, type GeneratedIndexSyncResult } from "../frontendBuild";
 import { prepareDevWatchBatch } from "./devWatchBatch";
 
+const prepare = (root: string, generation: number, file: string, indexSync: GeneratedIndexSyncResult) =>
+  prepareDevWatchBatch({
+    generation,
+    batch: { files: [file], kinds: new Set(["code"]) },
+    indexSync,
+    changePlanner: new DevChangePlanner({ workspaceRoot: root }),
+  });
+
 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 }),
-    });
+    const root = path.resolve("/repo");
+    const changedFile = path.join(root, "libs/shared/common/foo.ts");
+    const generatedIndex = path.join(root, "libs/shared/common/index.ts");
+    const prepared = prepare(root, 12, changedFile, { changedFiles: [generatedIndex], errors: [] });
 
     expect(prepared.hasSyncErrors).toBe(false);
     expect(prepared.files).toEqual([changedFile, generatedIndex]);
@@ -25,15 +29,10 @@ describe("prepareDevWatchBatch", () => {
   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 }),
-      });
+      const root = path.resolve("/repo");
+      const changedFile = path.join(root, "libs/shared", facet, "tmpExample.ts");
+      const generatedIndex = path.join(root, "libs/shared", facet, "index.ts");
+      const prepared = prepare(root, 20, changedFile, { changedFiles: [generatedIndex], errors: [] });
 
       expect(new Set(prepared.files)).toEqual(new Set([changedFile, generatedIndex]));
       expect(prepared.event.devPlan?.generatedFiles).toEqual([generatedIndex]);
@@ -44,11 +43,9 @@ describe("prepareDevWatchBatch", () => {
 
   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 }),
+    const prepared = prepare(root, 13, `${root}/libs/shared/common/foo.ts`, {
+      changedFiles: [],
+      errors: ["sync failed"],
     });
 
     expect(prepared.hasSyncErrors).toBe(true);