@akanjs/devkit 2.4.1-rc.6 → 2.4.1

package/frontendBuild/sourceMtimeIndex.ts

@@ -17,6 +17,12 @@ const UNREADABLE = Number.NaN;
 export interface SourceMtimeIndexOptions {
   roots: string[];
   classifier?: HmrChangeClassifier;
+  /**
+   * How close to "now" a directory's mtime may be before this scan's reading of it is treated as
+   * possibly stale. Raise it for a filesystem whose timestamps are coarser than the 1ms Linux stamps
+   * directories with — some network mounts stamp whole seconds.
+   */
+  dirSettleMs?: number;
 }
 
 /**
@@ -32,20 +38,41 @@ export interface SourceMtimeIndexOptions {
  * Re-stating the tracked set costs ~15ms against ~1300 source files here, where a fresh walk costs
  * ~70ms — the walk has to visit ~40k entries (`ios/`, `android/`, `public/`) to find those 1300. So
  * changes are found by re-stating known files plus re-reading only the directories whose own mtime
- * moved, which is what adding or removing an entry bumps.
+ * moved, which is what adding or removing an entry bumps — with one exception for the window in which
+ * that mtime cannot be trusted, see `#defaultDirSettleMs`.
  */
 export class SourceMtimeIndex {
+  /**
+   * How close to "now" a directory's mtime may be before this scan's reading of it is treated as
+   * possibly stale, and the directory re-read next time regardless of what its mtime says.
+   *
+   * Linux stamps directory times from a coarse clock. Measured on Bun 1.3.14 under Docker, 400
+   * back-to-back `mkdir`s left the parent's mtime unmoved **319 times on overlayfs and 324 times on
+   * ext4**, smallest observable step 1ms; macOS APFS (0.042ms) and a virtiofs bind mount (0.29ms) missed
+   * none. So a directory mutated in the same millisecond as the value this index recorded — but after the
+   * walk that recorded it — leaves no trace at all, and because its files were never tracked, later edits
+   * to them go unreported too. That is permanent for the life of the process, which is what makes it worth
+   * a second look rather than a note.
+   *
+   * 20ms covers a 1ms tick with room for a `HZ=100` kernel's 10ms, and costs one extra `readdir` per
+   * directory touched in the last 20ms — during a save, a handful.
+   */
+  static readonly #defaultDirSettleMs = 20;
+  readonly #dirSettleMs: number;
   readonly #roots: string[];
   readonly #classifier: HmrChangeClassifier;
   readonly #files = new Map<string, TrackedFile>();
   readonly #dirs = new Map<string, number>();
   readonly #unreadable = new Map<string, string>();
+  /** Directories whose recorded mtime was too fresh to trust, re-read on the next scan. */
+  readonly #unsettled = new Set<string>();
   #primed = false;
   #queue: Promise<unknown> = Promise.resolve();
 
-  constructor({ roots, classifier }: SourceMtimeIndexOptions) {
+  constructor({ roots, classifier, dirSettleMs }: SourceMtimeIndexOptions) {
     this.#roots = SourceMtimeIndex.#pruneNestedRoots(roots);
     this.#classifier = classifier ?? new HmrChangeClassifier();
+    this.#dirSettleMs = dirSettleMs ?? SourceMtimeIndex.#defaultDirSettleMs;
   }
 
   get primed(): boolean {
@@ -67,12 +94,22 @@ export class SourceMtimeIndex {
     return [...this.#unreadable].map(([file, code]) => ({ path: file, code }));
   }
 
+  /**
+   * Whether the last scan left a directory whose mtime was too fresh to trust. The caller should scan
+   * again once the timestamp has settled, since nothing else will look at that directory until something
+   * moves its mtime — and on a coarse clock the change that should have moved it already happened.
+   */
+  get hasUnsettledDirs(): boolean {
+    return this.#unsettled.size > 0;
+  }
+
   /** Record the current state as the baseline. Reports nothing; call before the first `collectChanges`. */
   async prime(): Promise<void> {
     await this.#serialize(async () => {
       this.#files.clear();
       this.#dirs.clear();
       this.#unreadable.clear();
+      this.#unsettled.clear();
       await Promise.all(this.#roots.map((root) => this.#walk(root, null)));
       this.#primed = true;
     });
@@ -168,7 +205,7 @@ export class SourceMtimeIndex {
    * content changes, so this finds creations and deletions the file pass cannot see.
    */
   async #collectDirChanges(changed: Set<string>): Promise<void> {
-    const moved: string[] = [];
+    const moved = new Set<string>();
     const gone: string[] = [];
     await Promise.all(
       [...this.#dirs.entries()].map(async ([dir, mtimeMs]) => {
@@ -183,9 +220,13 @@ export class SourceMtimeIndex {
         }
         // `UNREADABLE` is NaN, so a directory retained from a failed read always mismatches and is
         // rewalked here — that retry is what lets a transient failure recover on its own.
-        if (stats.mtimeMs !== mtimeMs) moved.push(dir);
+        if (stats.mtimeMs !== mtimeMs) moved.add(dir);
       }),
     );
+    // An unsettled directory is re-read whether or not its mtime moved: on a coarse clock a mutation
+    // that landed in the same tick as the recorded value leaves it identical, so the mtime is exactly
+    // the signal that cannot be trusted here.
+    for (const dir of this.#unsettled) if (this.#dirs.has(dir)) moved.add(dir);
     for (const dir of gone) this.#forget(dir);
     // Sequential: a moved directory can reveal a new subtree, and walking those in order keeps the
     // number of concurrent `readdir` calls proportional to the change rather than to the tree.
@@ -216,6 +257,8 @@ export class SourceMtimeIndex {
     const known = this.#dirs.has(dir);
     this.#dirs.set(dir, dirStats.mtimeMs);
     this.#unreadable.delete(dir);
+    if (this.#isUnsettled(dirStats.mtimeMs)) this.#unsettled.add(dir);
+    else this.#unsettled.delete(dir);
     const descend: string[] = [];
     const present = new Set<string>();
     let blind = false;
@@ -255,7 +298,11 @@ export class SourceMtimeIndex {
         changed?.add(abs);
       }
     }
-    if (blind) this.#dirs.set(dir, UNREADABLE);
+    // `UNREADABLE` already forces a re-walk every scan, so the freshness retry would only duplicate it.
+    if (blind) {
+      this.#dirs.set(dir, UNREADABLE);
+      this.#unsettled.delete(dir);
+    }
     // Known subdirectories carry their own mtime check, so only unseen ones need walking. Concurrent
     // because `prime` reaches every directory through here.
     await Promise.all(descend.filter((sub) => !this.#dirs.has(sub)).map((sub) => this.#walk(sub, changed)));
@@ -269,6 +316,7 @@ export class SourceMtimeIndex {
   #markUnreadable(dir: string, err: NodeJS.ErrnoException): void {
     this.#dirs.set(dir, UNREADABLE);
     this.#unreadable.set(dir, err.code ?? "EUNKNOWN");
+    this.#unsettled.delete(dir);
   }
 
   /** Drop a directory and everything the index holds beneath it. */
@@ -276,9 +324,22 @@ export class SourceMtimeIndex {
     const prefix = `${dir}${path.sep}`;
     this.#dirs.delete(dir);
     this.#unreadable.delete(dir);
+    this.#unsettled.delete(dir);
     for (const known of [...this.#dirs.keys()]) if (known.startsWith(prefix)) this.#dirs.delete(known);
     // Otherwise a gap under a deleted directory is reported forever, since nothing revisits it to clear.
     for (const known of [...this.#unreadable.keys()]) if (known.startsWith(prefix)) this.#unreadable.delete(known);
+    // Left behind, this would re-walk a path that no longer exists on every scan.
+    for (const known of [...this.#unsettled]) if (known.startsWith(prefix)) this.#unsettled.delete(known);
+  }
+
+  /**
+   * Whether a directory's mtime is recent enough that another mutation could share its timestamp tick.
+   *
+   * Symmetric so a filesystem clock running *ahead* of this process — a network mount, a container with a
+   * skewed host — does not read as permanently fresh and re-walk the whole tree on every scan.
+   */
+  #isUnsettled(mtimeMs: number): boolean {
+    return Math.abs(Date.now() - mtimeMs) < this.#dirSettleMs;
   }
 
   /** `null` stats with the errno kept, so callers can tell "not there" from "could not look". */

package/incrementalBuilder/buildBatchRunner.ts

@@ -74,7 +74,16 @@ export class BuildBatchRunner {
       );
       return result;
     }
-    const message = `build worker exited with code ${exitCode} before reporting a result`;
+    // A worker the kernel OOM-killed exits with code `null` and `SIGKILL`, which without the signal
+    // reads exactly like an ordinary crash — and the two have opposite fixes: one is a build error to
+    // find, the other is a memory limit to raise. The peak here is the largest transient in the tree
+    // (a boot build measured 548MB on a tenant app, 1.1GB on apps/akan), so on a small sandbox this is
+    // the process the kernel reaches for first.
+    const message = proc.signalCode
+      ? `build worker was killed by ${proc.signalCode} before reporting a result${
+          proc.signalCode === "SIGKILL" ? " — most often the kernel OOM killer; check the sandbox's memory limit" : ""
+        }`
+      : `build worker exited with code ${exitCode} before reporting a result`;
     this.#logger.error(`[build-batch] generation=${request.generation} ${message}`);
     return {
       generation: request.generation,

package/incrementalBuilder/builderChannel.test.ts

@@ -76,13 +76,22 @@ describe("BuilderChannel", () => {
     expect(await sendThenExit(200_000, { mode: "drain", payload: "css" })).toMatchObject([{ type: "css-updated" }]);
   });
 
-  test("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([]);
-  });
+  /**
+   * 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.
+   */
+  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;

package/incrementalBuilder/builderRequestRouter.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, test } from "bun:test";
+import type { BuilderReq, BuilderRes } from "akanjs/server";
+import { BuilderRequestRouter } from "./builderRequestRouter";
+
+const routeReq = (id: number, routeId: string): BuilderReq => ({
+  type: "build-route",
+  id,
+  routeId,
+  seeds: [],
+  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,
+  ok: true,
+  data: { manifestDelta: {}, ssrManifestDelta: {}, newEntries: [], clientDeps: [], routeId },
+});
+
+describe("BuilderRequestRouter", () => {
+  test("renumbers a request on the way out and restores the backend's id on the answer", () => {
+    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");
+    expect(first.id).not.toBe(second.id);
+    expect(router.inFlightCount).toBe(2);
+
+    expect(router.settle(routeRes(first.id, "/home"))?.id).toBe(1);
+    expect(router.settle(routeRes(second.id, "/about"))?.id).toBe(2);
+    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();
+    const stale = router.issue(routeReq(1, "/old"));
+
+    router.startGeneration();
+    const fresh = router.issue(routeReq(1, "/new"));
+    expect(fresh.id).not.toBe(stale.id);
+
+    expect(router.settle(routeRes(stale.id, "/old"))).toBeNull();
+    const answer = router.settle(routeRes(fresh.id, "/new"));
+    expect(answer?.id).toBe(1);
+    expect(answer?.data.routeId).toBe("/new");
+  });
+
+  test("drops an answer that arrives twice, and one nobody asked for", () => {
+    const router = new BuilderRequestRouter();
+    router.startGeneration();
+    const outgoing = router.issue(routeReq(7, "/home"));
+
+    expect(router.settle(routeRes(outgoing.id, "/home"))?.id).toBe(7);
+    expect(router.settle(routeRes(outgoing.id, "/home"))).toBeNull();
+    expect(router.settle(routeRes(9999, "/home"))).toBeNull();
+  });
+
+  test("withdraw releases an id whose send failed", () => {
+    const router = new 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();
+  });
+
+  test("abandons the previous generation's requests rather than carrying them forward", () => {
+    const router = new BuilderRequestRouter();
+    router.startGeneration();
+    router.issue(routeReq(1, "/a"));
+    router.issue(routeReq(2, "/b"));
+    expect(router.inFlightCount).toBe(2);
+
+    expect(router.startGeneration()).toBe(2);
+    expect(router.inFlightCount).toBe(0);
+  });
+});

package/incrementalBuilder/builderRequestRouter.ts

@@ -0,0 +1,66 @@
+import type { BuilderCsrReq, BuilderCsrRes, BuilderReq, BuilderRes } from "akanjs/server";
+
+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.
+ */
+export class BuilderRequestRouter {
+  #generation = 0;
+  #nextId = 1;
+  readonly #inFlight = new Map<number, { backendId: number; generation: number }>();
+
+  get generation(): number {
+    return this.#generation;
+  }
+
+  get inFlightCount(): number {
+    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.
+   */
+  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. */
+  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.
+   */
+  settle<T extends BuilderResponse>(message: T): T | null {
+    const request = this.#inFlight.get(message.id);
+    if (!request) return null;
+    this.#inFlight.delete(message.id);
+    if (request.generation !== this.#generation) return null;
+    return { ...message, id: request.backendId };
+  }
+}

package/incrementalBuilder/incrementalBuilder.host.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
+import { MemoryLimit } from "akanjs/server/memoryLimit";
 import { IncrementalBuilderHost } from "./incrementalBuilder.host";
 
 const originalSpawn = Bun.spawn;
@@ -77,6 +78,12 @@ describe("IncrementalBuilderHost", () => {
     expect(spawns[0]?.proc.kill).not.toHaveBeenCalled();
     expect(host.recycle("second request")).toBe(false);
 
+    // The drain refuses everything that arrives during it, so a request sent here is a request the
+    // developer gets an error page for. Reporting the state is what lets the host hold it instead.
+    expect(host.status).toBe("recycling");
+    expect(host.send({ type: "build-route", id: 9, routeId: "z", seeds: [], knownEntries: [] })).toBe(false);
+    expect(spawns[0]?.proc.send).toHaveBeenCalledTimes(1);
+
     // A planned exit skips the crash backoff — the dev server has no file watcher until it is back.
     spawns[0]?.options.onExit?.();
     expect(spawns).toHaveLength(2);
@@ -215,7 +222,12 @@ describe("IncrementalBuilderHost.maxRssBytes", () => {
     }
   };
 
-  test("defaults to a dev ceiling well above a fresh boot", () => {
+  /**
+   * Only where nothing else supplies a limit, which is not true in a container: a cgroup `memory.max`
+   * makes `resolveMaxRssBytes` derive from that instead. Measured under `docker --memory=7g`, this
+   * returned 2.45GiB rather than the fallback — the assertion was about the runner, not the code.
+   */
+  test.skipIf(MemoryLimit.readCgroupBytes() !== null)("defaults to a dev ceiling well above a fresh boot", () => {
     withEnv(
       { AKAN_BUILDER_MAX_RSS_MB: undefined, AKAN_BUILDER_MAX_RSS: undefined, AKAN_MEMORY_LIMIT: undefined },
       () => {
@@ -224,6 +236,21 @@ describe("IncrementalBuilderHost.maxRssBytes", () => {
     );
   });
 
+  test("derives the ceiling from the sandbox's own limit, wherever it runs", () => {
+    // The property the fallback test cannot assert in a container, stated so it holds on every runner:
+    // the builder gets 35% of whatever the sandbox is allowed.
+    withEnv(
+      {
+        AKAN_BUILDER_MAX_RSS_MB: undefined,
+        AKAN_BUILDER_MAX_RSS: undefined,
+        AKAN_MEMORY_LIMIT: String(4 * 1024 * 1024 * 1024),
+      },
+      () => {
+        expect(IncrementalBuilderHost.maxRssBytes()).toBe(Math.floor(4 * 1024 * 1024 * 1024 * 0.35));
+      },
+    );
+  });
+
   test("honors an explicit override and treats 0 as unbounded", () => {
     withEnv({ AKAN_BUILDER_MAX_RSS_MB: "700" }, () => {
       expect(IncrementalBuilderHost.maxRssBytes()).toBe(700 * 1024 * 1024);

package/incrementalBuilder/incrementalBuilder.host.ts

@@ -21,12 +21,22 @@ interface IncrementalBuilderHostOptions {
   onMessage: (message: BuilderMessage) => void;
 }
 
-type IncrementalBuilderStatus = "starting" | "ready" | "restarting" | "stopped";
+/**
+ * `recycling` is the drain: the builder is still alive and still holds the work it accepted, but it
+ * refuses anything new. Saying so here is what lets the host hold those requests for the replacement
+ * instead of handing the developer the refusal.
+ */
+export type IncrementalBuilderStatus = "starting" | "ready" | "recycling" | "restarting" | "stopped";
 
 interface IncrementalBuilderStartOptions {
   onExit?: () => void;
   onReady?: () => void;
   onRestartReady?: () => void;
+  /**
+   * The builder is gone and a replacement is on its way. Distinct from `onExit`, which reports the
+   * builder giving up: this one says the dev server is temporarily without a watcher.
+   */
+  onAway?: () => void;
   /**
    * Ask the builder to re-announce the artifact it boots with. Needed whenever a *previous* builder's
    * artifact may still be live in a running backend — after an rss recycle, and after an idle wake.
@@ -142,6 +152,9 @@ export class IncrementalBuilderHost {
           this.#startOptions.onExit?.();
           return;
         }
+        // Said once for both branches below, because both leave the tree unwatched until a replacement
+        // has primed its own index — and an edit that lands in that window is reported by nobody.
+        this.#startOptions.onAway?.();
         // A recycle is a planned exit, so it neither counts as a failed attempt nor waits out the
         // crash backoff — the dev server is without a watcher until the replacement is up.
         if (wasRecycle) {
@@ -182,6 +195,11 @@ export class IncrementalBuilderHost {
     const proc = this.#proc;
     if (!this.send({ type: "builder-shutdown", reason })) return false;
     this.#recycleRequested = true;
+    // From here the builder answers nothing new — it refuses every request that arrives during the
+    // drain. Leaving the status at `ready` is what used to let those requests through to be refused,
+    // one at a time, into the dev error page a recycle is supposed to be invisible to. `ready` the
+    // field is deliberately untouched: `onExit` reads it to tell a planned exit from a boot failure.
+    this.#status = "recycling";
     this.logger.info(`recycling builder pid=${proc.pid} (${reason})`);
     this.#recycleTimer = setTimeout(() => {
       this.#recycleTimer = null;
@@ -215,7 +233,11 @@ export class IncrementalBuilderHost {
   }
   send(message: BuilderMessage): boolean {
     if (!this.#proc || this.#status !== "ready") {
-      this.logger.warn(`incrementalBuilderHost is ${this.#status}; cannot send ${message.type}`);
+      // A builder on its way back is routine and the host holds what it refuses here, so only the
+      // states nothing is recovering from are worth a warning.
+      if (this.#status === "recycling" || this.#status === "restarting")
+        this.logger.verbose(`incrementalBuilderHost is ${this.#status}; ${message.type} is for the replacement`);
+      else this.logger.warn(`incrementalBuilderHost is ${this.#status}; cannot send ${message.type}`);
       return false;
     }
     try {

package/incrementalBuilder/incrementalBuilder.proc.ts

@@ -1,19 +1,19 @@
 import path from "node:path";
-// Subpath imports only: the `@akanjs/devkit` root barrel re-exports all 41 modules, which would drag
-// @trapezedev/project, the @langchain stack, ssh2, ink and the cloud stack into the builder process.
+// Module paths, never a barrel. The `@akanjs/devkit` root re-exports all 41 modules, which would drag
+// @trapezedev/project, the @langchain stack, ssh2, ink and the cloud stack in; and `frontendBuild`'s own
+// barrel reaches `cssCompiler`/`ssrBaseArtifactBuilder`, which pull tailwindcss + @tailwindcss/node
+// (~40MB) into a process that then holds them for the whole dev session. Phase 2 moved css compilation
+// into the batch worker, so this process has no use for them — `entryModuleGraph.test.ts` keeps it that way.
 import type { App } from "@akanjs/devkit/commandDecorators";
 import { AppExecutor, WorkspaceExecutor } from "@akanjs/devkit/executors";
-import {
-  AutoImportSync,
-  type ChangeBatch,
-  type ClientEntryDiscovery,
-  DevChangePlanner,
-  DevGeneratedIndexSync,
-  GraphClientEntryDiscovery,
-  HmrWatcher,
-  RouteClientBuilder,
-  WatchRootResolver,
-} from "@akanjs/devkit/frontendBuild";
+import { AutoImportSync } from "@akanjs/devkit/frontendBuild/autoImportSync";
+import type { ClientEntryDiscovery } from "@akanjs/devkit/frontendBuild/clientBuildTypes";
+import { GraphClientEntryDiscovery } from "@akanjs/devkit/frontendBuild/clientEntryDiscovery";
+import { DevChangePlanner } from "@akanjs/devkit/frontendBuild/devChangePlanner";
+import { DevGeneratedIndexSync } from "@akanjs/devkit/frontendBuild/devGeneratedIndexSync";
+import { HmrWatcher } from "@akanjs/devkit/frontendBuild/hmrWatcher";
+import { RouteClientBuilder } from "@akanjs/devkit/frontendBuild/routeClientBuilder";
+import { WatchRootResolver } from "@akanjs/devkit/frontendBuild/watchRootResolver";
 import { Logger } from "akanjs/common";
 import type {
   BaseBuildArtifact,
@@ -23,6 +23,7 @@ import type {
   BuilderRes,
   BuildPhase,
   BuildRouteResultPayload,
+  ChangeBatch,
 } from "akanjs/server";
 import type { BuildBatchNeed, BuildBatchRequest, BuildBatchResult, OptimizedFonts } from "./buildBatchProtocol";
 import { BuildBatchRunner } from "./buildBatchRunner";