@akanjs/cli 2.3.5 → 2.3.6-rc.1

package/incrementalBuilder.proc.js

@@ -2,7 +2,7 @@
 var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import path38 from "path";
+import path40 from "path";
 
 // pkgs/@akanjs/devkit/aiEditor.ts
 import { input, select } from "@inquirer/prompts";
@@ -3940,6 +3940,36 @@ var createTunnel = async (service, { app, environment, port = service === "postg
   return `localhost:${port}`;
 };
 
+// pkgs/@akanjs/devkit/incrementalBuilder/devWatchBatch.ts
+var prepareDevWatchBatch = ({
+  generation,
+  batch,
+  indexSync,
+  changePlanner
+}) => {
+  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];
+  const expandedBatch = { 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
+  };
+};
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
 import path8 from "path";
 import { Logger as Logger4 } from "akanjs/common";
@@ -3948,7 +3978,8 @@ var builderMsgTypeSet = new Set([
   "builder-ready",
   "invalidate",
   "css-updated",
-  "pages-updated"
+  "pages-updated",
+  "build-status"
 ]);
 
 class IncrementalBuilderHost {
@@ -4091,12 +4122,79 @@ var BUILDER_READY_TIMEOUT_MS = 15000;
 var BUILDER_START_MAX_ATTEMPTS = 3;
 var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav|html)$/i;
+var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
 var GRAPH_IMPORT_KINDS = new Set([
   "import-statement",
   "require-call",
   "require-resolve",
   "dynamic-import"
 ]);
+var shouldRestartBackendByDevPlan = (message) => {
+  if (!message.devPlan)
+    return null;
+  if (message.devPlan.actions.includes("report-error"))
+    return false;
+  if (message.devPlan.actions.includes("restart-builder"))
+    return false;
+  return message.devPlan.actions.includes("restart-backend");
+};
+var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includes("restart-builder") ?? false;
+var shouldRestartDevHostByDevPlan = (message) => message.devPlan?.actions.includes("restart-dev-host") ?? message.kinds.includes("config");
+var RESTART_ROLE_ORDER = ["server", "shared", "barrel", "config"];
+var generationValue = (generation) => generation ?? -1;
+var isLegacyBackendFallbackFile = (file, workspaceRoot) => {
+  const abs = path9.resolve(file);
+  const ext = path9.extname(abs).toLowerCase();
+  if (!SOURCE_EXTS.has(ext))
+    return false;
+  const rel = path9.relative(path9.resolve(workspaceRoot), abs);
+  if (!rel || rel.startsWith("..") || path9.isAbsolute(rel))
+    return false;
+  const parts = rel.split(path9.sep).filter(Boolean);
+  const [scope] = parts;
+  if (scope !== "apps" && scope !== "libs" && scope !== "pkgs")
+    return false;
+  const base = path9.basename(abs);
+  return parts.includes("srvkit") || parts.includes("common") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base) || base === "main.ts" || base === "server.ts";
+};
+var shouldMarkBuildPhaseRecovered = (previousByPhase, status) => {
+  const previous = previousByPhase.get(status.phase);
+  return Boolean(previous && status.ok && !previous.ok && generationValue(status.generation) >= previous.generation);
+};
+var createBackendBuildStatus = ({
+  generation,
+  ok,
+  files = [],
+  message
+}) => ({
+  generation,
+  phase: "backend",
+  ok,
+  files,
+  message
+});
+var backendRestartReasonFromMessage = (message) => {
+  const roleSet = new Set;
+  for (const role of message.devPlan?.roles ?? []) {
+    if (role === "server" || role === "shared" || role === "barrel" || role === "config")
+      roleSet.add(role);
+  }
+  return {
+    generation: message.devPlan?.generation ?? message.generation,
+    files: [...new Set(message.files)].sort(),
+    roles: RESTART_ROLE_ORDER.filter((role) => roleSet.has(role))
+  };
+};
+var mergeBackendRestartReasons = (current, next) => ({
+  generation: generationValue(next.generation) >= generationValue(current?.generation) ? next.generation : current?.generation,
+  files: [...new Set([...current?.files ?? [], ...next.files])].sort(),
+  roles: RESTART_ROLE_ORDER.filter((role) => current?.roles.includes(role) || next.roles.includes(role))
+});
+var shouldReplaceLastGoodMessage = (current, next) => !current || generationValue(next.data.generation) >= generationValue(current.data.generation);
+var shouldQueueBuildStatusReplay = (backendReady, pendingReplayCount) => !backendReady || pendingReplayCount > 0;
+var buildStatusReplaySequence = (pendingReplay, latestByPhase) => [...pendingReplay, ...latestByPhase.values()];
 
 class BackendImportGraph {
   #app;
@@ -4107,6 +4205,7 @@ class BackendImportGraph {
   #jsxTranspiler = new Bun.Transpiler({ loader: "jsx" });
   #files = new Set;
   #ready = false;
+  #lastRefreshSucceeded = false;
   constructor(app, logger) {
     this.#app = app;
     this.#logger = logger;
@@ -4114,6 +4213,9 @@ class BackendImportGraph {
   get ready() {
     return this.#ready;
   }
+  get lastRefreshSucceeded() {
+    return this.#lastRefreshSucceeded;
+  }
   has(file) {
     return this.#files.has(path9.resolve(file));
   }
@@ -4122,10 +4224,12 @@ class BackendImportGraph {
       const files = await this.#build();
       this.#files = files;
       this.#ready = true;
+      this.#lastRefreshSucceeded = true;
       this.#logger.verbose(`[backend-graph] scanned ${files.size} files`);
       return true;
     } catch (err) {
       this.#ready = this.#files.size > 0;
+      this.#lastRefreshSucceeded = false;
       this.#logger.warn(`[backend-graph] scan failed; ${this.#ready ? "using previous graph" : "using fallback rules"}: ${err instanceof Error ? err.message : String(err)}`);
       return this.#ready;
     }
@@ -4212,9 +4316,13 @@ class AkanAppHost {
   #restartTimer = null;
   #backendRecoveryTimer = null;
   #backendRecoveryAttempts = 0;
-  #restartFiles = new Set;
-  #latestPagesUpdated = null;
-  #latestCssUpdated = null;
+  #backendLifecycleState = "stopped";
+  #pendingRestartReason = null;
+  #backendStartStatus = null;
+  #backendBuildStatusGeneration = 0;
+  #lastGoodFrontend = {};
+  #buildStatusByPhase = new Map;
+  #pendingBuildStatusReplay = [];
   #builderMessageQueue = Promise.resolve();
   #backendGraph;
   constructor(app, { env, withInk = false }) {
@@ -4259,7 +4367,9 @@ class AkanAppHost {
       return "localhost";
     return await createTunnel(type, { app: this.app, environment });
   }
-  #startBackend() {
+  #startBackend(startStatus = null) {
+    this.#backendStartStatus = startStatus;
+    this.#setBackendLifecycleState("starting");
     this.#backendReady = false;
     const backend = Bun.spawn(["bun", `apps/${this.app.name}/main.ts`], {
       cwd: this.app.workspace.workspaceRoot,
@@ -4271,6 +4381,8 @@ class AkanAppHost {
         if (msg.type === "backend-ready") {
           this.#backendReady = true;
           this.#backendRecoveryAttempts = 0;
+          this.#setBackendLifecycleState("ready", `pid=${msg.pid}`);
+          this.#recordBackendReadyStatus();
           this.logger.verbose(`backend ready pid=${msg.pid}`);
           this.#replayBuilderState();
           return;
@@ -4293,9 +4405,53 @@ class AkanAppHost {
     this.#backend = backend;
     this.logger.verbose(`backend spawned pid=${backend.pid}`);
   }
+  #nextBackendBuildStatusGeneration(generation) {
+    if (typeof generation === "number") {
+      this.#backendBuildStatusGeneration = Math.max(this.#backendBuildStatusGeneration, generation);
+      return generation;
+    }
+    this.#backendBuildStatusGeneration += 1;
+    return this.#backendBuildStatusGeneration;
+  }
+  #recordBackendBuildStatus({
+    generation,
+    ok,
+    files,
+    message
+  }) {
+    const status = createBackendBuildStatus({
+      generation: this.#nextBackendBuildStatusGeneration(generation),
+      ok,
+      files,
+      message
+    });
+    this.#recordBuildStatus(status);
+    return status;
+  }
+  #recordBackendReadyStatus() {
+    const previous = this.#buildStatusByPhase.get("backend");
+    const startStatus = this.#backendStartStatus;
+    if (startStatus || previous?.ok === false) {
+      const status = this.#recordBackendBuildStatus({
+        generation: startStatus?.generation ?? previous?.generation,
+        ok: true,
+        files: startStatus?.files ?? previous?.files ?? [],
+        message: "Backend ready"
+      });
+      this.#sendOrQueueBuildStatus(status);
+    }
+    this.#backendStartStatus = null;
+  }
+  #setBackendLifecycleState(next, detail) {
+    if (this.#backendLifecycleState === next && !detail)
+      return;
+    const prev = this.#backendLifecycleState;
+    this.#backendLifecycleState = next;
+    this.logger.verbose(`[backend-lifecycle] ${prev} -> ${next}${detail ? ` ${detail}` : ""}`);
+  }
   #sendToBackend(message) {
     if (!this.#backend || !this.#backendReady) {
-      if (message.type === "css-updated" || message.type === "pages-updated") {
+      if (message.type === "css-updated" || message.type === "pages-updated" || message.type === "build-status") {
         this.logger.verbose(`backend is not ready; will replay ${message.type}`);
         return;
       }
@@ -4315,6 +4471,7 @@ class AkanAppHost {
     const backend = this.#backend;
     this.#plannedBackendStops.add(backend);
     this.#backendReady = false;
+    this.#setBackendLifecycleState("stopping", `pid=${backend.pid}`);
     this.logger.verbose(`stopping backend pid=${backend.pid}`);
     try {
       backend.kill("SIGTERM");
@@ -4330,11 +4487,13 @@ class AkanAppHost {
     } finally {
       if (this.#backend === backend)
         this.#backend = null;
+      this.#setBackendLifecycleState("stopped", `pid=${backend.pid}`);
     }
   }
-  #scheduleBackendRestart(files) {
-    for (const file of files)
-      this.#restartFiles.add(file);
+  #scheduleBackendRestart(reason) {
+    this.#pendingRestartReason = mergeBackendRestartReasons(this.#pendingRestartReason, reason);
+    const pending = this.#pendingRestartReason;
+    this.#setBackendLifecycleState("restart-pending", `generation=${pending.generation ?? "(unknown)"} files=${pending.files.length} roles=${pending.roles.join(",") || "(none)"}`);
     if (this.#backendRecoveryTimer) {
       clearTimeout(this.#backendRecoveryTimer);
       this.#backendRecoveryTimer = null;
@@ -4343,23 +4502,31 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
-      const changed = [...this.#restartFiles];
-      this.#restartFiles.clear();
-      this.#restartBackend(changed);
+      const next = this.#pendingRestartReason;
+      this.#pendingRestartReason = null;
+      if (next)
+        this.#restartBackend(next);
     }, BACKEND_RESTART_DEBOUNCE_MS);
   }
-  async#restartBackend(files) {
-    this.logger.verbose(`[backend-reload] restarting backend for ${files.length} file(s)`);
+  async#restartBackend(reason) {
+    this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
     this.#backendRecoveryAttempts = 0;
     await Promise.all([this.#stopBackend(), this.#backendGraph.refresh()]);
-    this.#startBackend();
+    this.#startBackend({ generation: reason.generation, files: reason.files });
   }
   #scheduleBackendRecovery(reason) {
     if (this.#backendRecoveryTimer || this.#backend)
       return;
+    this.#setBackendLifecycleState("recovering", reason);
     const attempt = this.#backendRecoveryAttempts;
     const delay = Math.min(BACKEND_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BACKEND_RECOVERY_MAX_DELAY_MS);
     this.#backendRecoveryAttempts = attempt + 1;
+    const failureStatus = this.#recordBackendBuildStatus({
+      ok: false,
+      files: [],
+      message: `Backend exited unexpectedly (${reason}); restarting in ${delay}ms`
+    });
+    this.#sendOrQueueBuildStatus(failureStatus);
     this.logger.warn(`[backend-recovery] backend exited unexpectedly (${reason}); restarting in ${delay}ms (attempt ${this.#backendRecoveryAttempts})`);
     this.#backendRecoveryTimer = setTimeout(() => {
       this.#backendRecoveryTimer = null;
@@ -4367,7 +4534,7 @@ class AkanAppHost {
         return;
       this.#backendGraph.refresh().finally(() => {
         if (!this.#backend)
-          this.#startBackend();
+          this.#startBackend({ generation: failureStatus.generation, files: failureStatus.files });
       });
     }, delay);
   }
@@ -4377,10 +4544,15 @@ class AkanAppHost {
     });
   }
   async#handleBuilderMessage(message) {
+    if (message.type === "build-status") {
+      this.#recordBuildStatus(message.data);
+      this.#sendOrQueueBuildStatus(message.data);
+      return;
+    }
     if (message.type === "pages-updated")
-      this.#latestPagesUpdated = message;
+      this.#recordLastGood(message);
     if (message.type === "css-updated")
-      this.#latestCssUpdated = message;
+      this.#recordLastGood(message);
     if (message.type === "invalidate") {
       await this.#handleInvalidate(message);
       return;
@@ -4388,26 +4560,140 @@ class AkanAppHost {
     this.#sendToBackend(message);
   }
   async#handleInvalidate(message) {
+    if (shouldRestartBuilderByDevPlan(message)) {
+      try {
+        await this.#restartDevChildren(message);
+      } catch (err) {
+        this.#recordDevHostRestartFailure(message, err);
+      }
+      return;
+    }
+    if (shouldRestartDevHostByDevPlan(message)) {
+      this.#recordDevHostRestartRequired(message);
+      return;
+    }
     if (await this.#shouldRestartBackend(message)) {
-      this.#scheduleBackendRestart(message.files);
+      this.#scheduleBackendRestart(backendRestartReasonFromMessage(message));
       return;
     }
     this.#sendToBackend(message);
   }
+  async#restartDevChildren(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    this.logger.warn(`[dev-host] recycling builder/backend for runtime metadata generation=${generation ?? "(unknown)"} files=${message.files.length}`);
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
+    this.#pendingRestartReason = null;
+    this.#lastGoodFrontend = {};
+    this.#buildStatusByPhase.clear();
+    this.#pendingBuildStatusReplay = [];
+    await this.#stopBackend();
+    this.#stopBuilder();
+    await this.#backendGraph.refresh();
+    await this.#startBuilder();
+    this.#startBackend({ generation, files: message.files });
+  }
+  #recordLastGood(message) {
+    if (message.type === "pages-updated") {
+      if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.pages, message))
+        return;
+      this.#lastGoodFrontend.pages = message;
+      this.logger.verbose(`[last-good] pages generation=${message.data.generation ?? "(unknown)"} buildId=${message.data.buildId}`);
+      return;
+    }
+    if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.css, message))
+      return;
+    this.#lastGoodFrontend.css = message;
+    this.logger.verbose(`[last-good] css generation=${message.data.generation ?? "(unknown)"} assets=${Object.keys(message.data.cssAssets).length}`);
+  }
+  #recordDevHostRestartRequired(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    const detail = `generation=${generation ?? "(unknown)"} files=${message.files.length}`;
+    this.logger.warn(`[dev-host] config change requires a manual restart until controlled dev-host restart is implemented (${detail})`);
+    if (typeof generation === "number") {
+      const status = {
+        generation,
+        phase: "scan",
+        ok: false,
+        files: message.files,
+        message: "Config change requires restarting `akan start` to apply."
+      };
+      this.#recordBuildStatus(status);
+      this.#sendOrQueueBuildStatus(status);
+    }
+  }
+  #recordDevHostRestartFailure(message, err) {
+    const generation = message.devPlan?.generation ?? message.generation ?? this.#nextBackendBuildStatusGeneration();
+    const detail = err instanceof Error ? err.message : String(err);
+    this.logger.warn(`[dev-host] runtime metadata restart failed generation=${generation}: ${detail}`);
+    const status = {
+      generation,
+      phase: "scan",
+      ok: false,
+      files: message.files,
+      message: `Runtime metadata change requires restarting \`akan start\` to apply: ${detail}`
+    };
+    this.#recordBuildStatus(status);
+    this.#sendOrQueueBuildStatus(status);
+  }
+  #recordBuildStatus(status) {
+    const recovered = shouldMarkBuildPhaseRecovered(this.#buildStatusByPhase, status);
+    this.#buildStatusByPhase.set(status.phase, status);
+    const label = `[build-status] generation=${status.generation} phase=${status.phase} ok=${status.ok} files=${status.files.length}`;
+    if (status.ok)
+      this.logger.verbose(`${label}${recovered ? " recovered=1" : ""}`);
+    else
+      this.logger.warn(`${label}${status.message ? ` message=${status.message}` : ""}`);
+  }
+  #sendOrQueueBuildStatus(status) {
+    if (!this.#backend || shouldQueueBuildStatusReplay(this.#backendReady, this.#pendingBuildStatusReplay.length)) {
+      this.#pendingBuildStatusReplay.push(status);
+      this.logger.verbose(`backend is not ready; will replay build-status generation=${status.generation} phase=${status.phase}`);
+      return;
+    }
+    this.#sendToBackend({ type: "build-status", data: status });
+  }
   #replayBuilderState() {
     if (!this.#backendReady)
       return;
-    if (this.#latestCssUpdated)
-      this.#sendToBackend(this.#latestCssUpdated);
-    if (this.#latestPagesUpdated)
-      this.#sendToBackend(this.#latestPagesUpdated);
+    if (this.#lastGoodFrontend.css)
+      this.#sendToBackend(this.#lastGoodFrontend.css);
+    if (this.#lastGoodFrontend.pages)
+      this.#sendToBackend(this.#lastGoodFrontend.pages);
+    const queuedStatuses = this.#pendingBuildStatusReplay.splice(0);
+    for (const status of buildStatusReplaySequence(queuedStatuses, this.#buildStatusByPhase)) {
+      this.#sendToBackend({ type: "build-status", data: status });
+    }
   }
   async#shouldRestartBackend(message) {
     if (message.kinds.length === 1 && message.kinds[0] === "css")
       return false;
-    if (!this.#backendGraph.ready && message.kinds.includes("code"))
+    if (message.devPlan) {
+      const { generation, roles, actions, reasonByFile } = message.devPlan;
+      this.logger.verbose(`[dev-plan] generation=${generation} roles=${roles.join(",") || "(none)"} actions=${actions.join(",") || "(none)"} reasons=${Object.keys(reasonByFile).length}`);
+      const shouldRestart = shouldRestartBackendByDevPlan(message) ?? false;
+      if (shouldRestart && message.kinds.includes("code"))
+        await this.#backendGraph.refresh();
+      return shouldRestart;
+    }
+    if (message.kinds.includes("code"))
       await this.#backendGraph.refresh();
-    return message.files.some((file) => this.#isBackendFile(file));
+    if (message.files.some((file) => this.#isBackendFile(file)))
+      return true;
+    if (!this.#backendGraph.lastRefreshSucceeded) {
+      const fallbackFiles = message.files.filter((file) => isLegacyBackendFallbackFile(file, this.app.workspace.workspaceRoot));
+      if (fallbackFiles.length > 0) {
+        this.logger.warn(`[backend-graph] using path-role fallback for legacy invalidate; restart files=${fallbackFiles.length}`);
+        return true;
+      }
+    }
+    return false;
   }
   #isBackendFile(file) {
     return this.#backendGraph.has(file);
@@ -4763,8 +5049,8 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
   }
 }
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
-import { mkdir as mkdir7, rm as rm2 } from "fs/promises";
-import path33 from "path";
+import { mkdir as mkdir8, rm as rm3 } from "fs/promises";
+import path35 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
 import path20 from "path";
@@ -7232,9 +7518,306 @@ function getPageKeyBasePath(pageKey, basePaths) {
   const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
   return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
 }
-// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
-import { mkdir as mkdir6 } from "fs/promises";
+// pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
 import path25 from "path";
+var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+var BARREL_FACETS = new Set(["common", "srvkit", "ui", "webkit"]);
+var CLIENT_SUFFIXES = [".Template.tsx", ".Unit.tsx", ".Util.tsx", ".View.tsx", ".Zone.tsx", ".store.ts"];
+var SHARED_SUFFIXES2 = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var SERVER_SUFFIXES2 = [".service.ts", ".document.ts"];
+var RUNTIME_METADATA_BASENAMES2 = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+
+class DevChangePlanner {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path25.resolve(workspaceRoot);
+  }
+  plan({ generation, files, kinds, generatedFiles: generatedFiles2 = [] }) {
+    const fileList = uniqueResolved([...files, ...generatedFiles2]);
+    const generatedSet = new Set(generatedFiles2.map((file) => path25.resolve(file)));
+    const kindSet = new Set(kinds);
+    const roles = new Set;
+    const actions = new Set;
+    const reasonByFile = {};
+    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;
+      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path25.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[path25.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(generatedFiles2),
+      roles: [...roles].sort(),
+      actions: [...actions].sort(),
+      reasonByFile
+    };
+  }
+  #rolesForFile(file, { isGenerated, reasons }) {
+    const roles = new Set;
+    const abs = path25.resolve(file);
+    const base = path25.basename(abs);
+    const ext = path25.extname(abs).toLowerCase();
+    const isSource = SOURCE_EXTS4.has(ext);
+    const rel = path25.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path25.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_EXTS4.has(ext) && this.#isWorkspaceSource(rel)) {
+      roles.add("shared");
+      reasons.add("workspace-source-fallback");
+    }
+    return roles;
+  }
+  #isServerBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("srvkit") || SERVER_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
+  }
+  #isClientBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
+  }
+  #isSharedBiased(abs, parts) {
+    const base = path25.basename(abs);
+    return parts.includes("common") || SHARED_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES2.has(base);
+  }
+  #isRuntimeMetadataFile(parts, base) {
+    const parent = parts.at(-2);
+    if (parent === "lib" && RUNTIME_METADATA_BASENAMES2.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) {
+    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) {
+    if (!rel || rel.startsWith("..") || path25.isAbsolute(rel))
+      return false;
+    const [scope] = rel.split(path25.sep);
+    return scope === "apps" || scope === "libs" || scope === "pkgs";
+  }
+}
+var uniqueResolved = (files) => [...new Set(files.map((file) => path25.resolve(file)))].sort();
+// pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
+import { mkdir as mkdir6, readdir as readdir2, readFile, rm as rm2, stat as stat3, writeFile } from "fs/promises";
+import path26 from "path";
+var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit"]);
+var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
+var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
+var MODULE_UI_TYPES = ["Template", "Unit", "Util", "View", "Zone"];
+var SERVICE_UI_TYPES = ["Util", "Zone"];
+var SCALAR_UI_TYPES = ["Template", "Unit"];
+
+class DevGeneratedIndexSync {
+  #workspaceRoot;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path26.resolve(workspaceRoot);
+  }
+  async syncForBatch(files) {
+    const indexPaths = new Set;
+    const errors = [];
+    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 = [];
+    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) {
+    const abs = path26.resolve(file);
+    const rel = path26.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path26.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path26.sep).filter(Boolean);
+    if (parts.length < 4)
+      return null;
+    const [scope, project, facet, child] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || !facet || !BARREL_FACETS2.has(facet))
+      return null;
+    if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
+      return null;
+    return path26.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+  }
+  async#moduleIndexForDirectoryEvent(file) {
+    const abs = path26.resolve(file);
+    const rel = path26.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path26.isAbsolute(rel))
+      return null;
+    const parts = rel.split(path26.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 stat3(abs).then((s) => s.isDirectory()).catch(() => false);
+    const looksLikeDeletedDirectory = !path26.extname(abs);
+    if (!isExistingDirectory && !looksLikeDeletedDirectory)
+      return null;
+    if (moduleSegment === "__scalar" && scalarSegment) {
+      return path26.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+    }
+    if (!moduleSegment || moduleSegment === "__scalar")
+      return null;
+    return path26.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+  }
+  async#syncIndex(indexPath) {
+    const dir = path26.dirname(indexPath);
+    const content = await this.#contentForIndex(indexPath);
+    if (content === null) {
+      if (!await exists(indexPath))
+        return false;
+      await rm2(indexPath, { force: true });
+      return true;
+    }
+    const current = await readFile(indexPath, "utf8").catch(() => null);
+    if (current === content)
+      return false;
+    await mkdir6(dir, { recursive: true });
+    await writeFile(indexPath, content);
+    return true;
+  }
+  async#contentForIndex(indexPath) {
+    const parts = path26.relative(this.#workspaceRoot, indexPath).split(path26.sep).filter(Boolean);
+    const facet = parts.at(-2);
+    if (facet && BARREL_FACETS2.has(facet))
+      return this.#facetContent(path26.dirname(indexPath));
+    return this.#moduleContent(path26.dirname(indexPath));
+  }
+  async#facetContent(dir) {
+    const entries = await readdir2(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(`
+`)}
+`;
+  }
+  async#moduleContent(dir) {
+    const rel = path26.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path26.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 = capitalize3(rawModel);
+    const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
+    const fileTypes = [];
+    for (const type of allowedTypes) {
+      if (await exists(path26.join(dir, `${modelName}.${type}.tsx`)))
+        fileTypes.push(type);
+    }
+    if (fileTypes.length === 0)
+      return null;
+    return `
+${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).join(`
+`)}
+
+export const ${modelName} = { ${fileTypes.join(", ")} };`;
+  }
+}
+var exists = async (file) => stat3(file).then(() => true).catch(() => false);
+var capitalize3 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+// pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
+import { mkdir as mkdir7 } from "fs/promises";
+import path27 from "path";
 import {
   generateFontFace,
   getMetricsForFamily,
@@ -7258,7 +7841,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path25.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path27.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -7277,7 +7860,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path25.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path27.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -7293,8 +7876,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path25.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir6(path25.dirname(outputPath), { recursive: true });
+      const outputPath = path27.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir7(path27.dirname(outputPath), { recursive: true });
       const sourceBuffer = Buffer.from(await Bun.file(sourcePath).arrayBuffer());
       const outputBuffer = font.subset === false ? await this.#convertToWoff2(sourceBuffer, sourcePath) : await subsetFont(sourceBuffer, await this.#getSubsetText(font), { targetFormat: "woff2" });
       await Bun.write(outputPath, outputBuffer);
@@ -7441,8 +8024,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path25.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path25.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path27.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path27.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -7470,7 +8053,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path25.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path27.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -7479,7 +8062,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path25.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path27.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -7489,7 +8072,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path25.isAbsolute(filePath) ? filePath : path25.join(this.#app.cwdPath, filePath);
+      const abs = path27.isAbsolute(filePath) ? filePath : path27.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -7508,7 +8091,7 @@ class FontOptimizer {
     return "";
   }
   async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path25.join(this.#app.cwdPath, dir));
+    const roots = ["page", "ui"].map((dir) => path27.join(this.#app.cwdPath, dir));
     const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,html,md}");
     const parts = [];
     await Promise.all(roots.map(async (root) => {
@@ -7622,43 +8205,43 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path26 from "path";
-var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+import path28 from "path";
+var SOURCE_EXTS5 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CSS_EXTS = new Set([".css"]);
-var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
+var CONFIG_BASENAMES2 = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
 
 class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path26.basename(abs);
-    if (CONFIG_BASENAMES.has(base))
+    const base = path28.basename(abs);
+    if (CONFIG_BASENAMES2.has(base))
       return "config";
-    const ext = path26.extname(abs).toLowerCase();
+    const ext = path28.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
-    if (SOURCE_EXTS4.has(ext))
+    if (SOURCE_EXTS5.has(ext))
       return "code";
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path26.basename(abs);
+    const base = path28.basename(abs);
     if (!base)
       return true;
     if (base.startsWith("."))
       return true;
     if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx") || base.endsWith(".tmp"))
       return true;
-    if (abs.includes(`${path26.sep}node_modules${path26.sep}`))
+    if (abs.includes(`${path28.sep}node_modules${path28.sep}`))
       return true;
-    if (abs.includes(`${path26.sep}.akan${path26.sep}`))
+    if (abs.includes(`${path28.sep}.akan${path28.sep}`))
       return true;
     return false;
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs4 from "fs";
-import path27 from "path";
+import path29 from "path";
 class HmrWatcher {
   #roots;
   #debounceMs;
@@ -7671,7 +8254,7 @@ class HmrWatcher {
   #stopped = false;
   #flushing = false;
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path27.resolve(r)))];
+    this.#roots = [...new Set(opts.roots.map((r) => path29.resolve(r)))];
     this.#debounceMs = opts.debounceMs ?? 80;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -7682,7 +8265,7 @@ class HmrWatcher {
         const w = fs4.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path27.resolve(root, filename.toString());
+          const abs = path29.resolve(root, filename.toString());
           this.#queue(abs);
         });
         this.#watchers.push(w);
@@ -7740,10 +8323,10 @@ class HmrWatcher {
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path29 from "path";
+import path31 from "path";
 
 // pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path28 from "path";
+import path30 from "path";
 var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
 var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "@akanjs/cli", "@akanjs/devkit"]);
 var DEFAULT_EXCLUDE_PREFIX = ["@akanjs/cli/", "@akanjs/devkit/"];
@@ -7786,7 +8369,7 @@ async function createExternalizeFrameworkPlugin(options) {
         const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
         if (!replPath)
           continue;
-        const candidate = path28.resolve(workspaceRoot, replPath + suffix);
+        const candidate = path30.resolve(workspaceRoot, replPath + suffix);
         const hit = await firstExisting(candidate);
         if (hit)
           return hit;
@@ -7798,8 +8381,8 @@ async function createExternalizeFrameworkPlugin(options) {
       if (spec === pkg)
         continue;
       const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path28.dirname(path28.resolve(workspaceRoot, entryFile));
-      const candidate = path28.join(pkgDir, suffix);
+      const pkgDir = path30.dirname(path30.resolve(workspaceRoot, entryFile));
+      const candidate = path30.join(pkgDir, suffix);
       const hit = await firstExisting(candidate);
       if (hit)
         return hit;
@@ -7849,7 +8432,7 @@ async function firstExisting(basePath2) {
       return candidate;
   }
   for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path28.join(basePath2, `index${ext}`);
+    const candidate = path30.join(basePath2, `index${ext}`);
     if (await Bun.file(candidate).exists())
       return candidate;
   }
@@ -7940,11 +8523,11 @@ class PagesBundleBuilder {
     const entryArtifact = result.outputs.find((a) => a.kind === "entry-point");
     if (!entryArtifact)
       throw new Error("[PagesBundleBuilder] Bun.build emitted no entry-point artifact");
-    const bundlePath = path29.resolve(entryArtifact.path);
+    const bundlePath = path31.resolve(entryArtifact.path);
     const buildId = Date.now();
     const outputBytes = result.outputs.reduce((sum, output) => sum + output.size, 0);
     const chunkCount = result.outputs.filter((output) => output.kind === "chunk").length;
-    this.#app.verbose(`[PagesBundleBuilder] ${path29.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
+    this.#app.verbose(`[PagesBundleBuilder] ${path31.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
     return {
       bundlePath,
       buildId,
@@ -8026,11 +8609,11 @@ function loaderFor4(absPath) {
 }
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
 import fs5 from "fs";
-import path30 from "path";
+import path32 from "path";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
 async function precompressArtifacts(app) {
-  const roots = [path30.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const roots = [path32.join(app.dist.cwdPath, ".akan/artifact/client")];
   const result = { files: 0, inputBytes: 0, outputBytes: 0 };
   await Promise.all(roots.map((root) => precompressRoot(root, result)));
   if (result.files > 0) {
@@ -8056,7 +8639,7 @@ async function precompressRoot(root, result) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path30.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path32.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -8074,7 +8657,7 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path31 from "path";
+import path33 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath2, cssText) {
   return optimize(cssText, { file: `${basePath2 || "root"}.css`, minify: command === "build" }).code;
@@ -8090,7 +8673,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path31.resolve(this.#artifactDir);
+    this.#absArtifactDir = path33.resolve(this.#artifactDir);
   }
   async build() {
     const akanConfig2 = await this.#app.getConfig();
@@ -8112,7 +8695,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path31.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path33.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
       pagesBundleBuildId: pagesBundle.buildId,
       domains: [...akanConfig2.domains],
       subRoutes: Object.fromEntries(Array.from(akanConfig2.subRoutes.entries()).map(([basePath2, domains]) => [basePath2, [...domains]])),
@@ -8121,7 +8704,7 @@ class SsrBaseArtifactBuilder {
       i18n: akanConfig2.i18n,
       imageConfig: akanConfig2.images
     };
-    await Bun.write(path31.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path33.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
 `);
     this.#app.verbose(`[base-artifact] complete in ${Date.now() - this.#started}ms`);
     return { artifact, seedIndex, cssCompiler, optimizedFonts };
@@ -8169,15 +8752,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path31.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path31.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path33.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", path31.dirname(Bun.main))));
+      candidates.push(path33.dirname(Bun.resolveSync("akanjs/server", path33.dirname(Bun.main))));
     } catch {}
-    candidates.push(path31.join(path31.dirname(Bun.main), "node_modules/akanjs/server"), path31.join(path31.dirname(Bun.main), "../../akanjs/server"), path31.resolve(import.meta.dir, "../../server"), path31.resolve(import.meta.dir, "../server"));
+    candidates.push(path33.join(path33.dirname(Bun.main), "node_modules/akanjs/server"), path33.join(path33.dirname(Bun.main), "../../akanjs/server"), path33.resolve(import.meta.dir, "../../server"), path33.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path31.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path33.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -8206,14 +8789,14 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path31.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path33.join(this.#absArtifactDir, cssRelPath), preparedCssText);
     this.#app.verbose(`[base-artifact] wrote ${preparedCssText.length} bytes of CSS for ${basePath2} -> ${cssRelPath}`);
     return [basePath2, { cssUrl, cssRelPath }];
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
 import fs6 from "fs";
-import path32 from "path";
+import path34 from "path";
 
 class WatchRootResolver {
   #app;
@@ -8223,15 +8806,15 @@ class WatchRootResolver {
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
     const set = new Set;
-    set.add(path32.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path34.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path32.isAbsolute(target))
+        if (path34.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path32.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path34.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (fs6.existsSync(resolved))
           set.add(resolved);
       }
@@ -8298,7 +8881,7 @@ class ApplicationBuildRunner {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path33.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path35.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
@@ -8306,7 +8889,7 @@ class ApplicationBuildRunner {
     await this.#app.getPageKeys({ refresh: true });
     const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
     if (clean)
-      await rm2(path33.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm3(path35.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
   async#runPhase(id, label, task, summarize, options = {}) {
@@ -8378,7 +8961,7 @@ class ApplicationBuildRunner {
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path33.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+    await Bun.write(path35.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
 import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
 
 const run = async () => {
@@ -8401,14 +8984,14 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path33.join(path33.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path35.join(path35.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
   async#buildCsr() {
@@ -8425,8 +9008,8 @@ void run().catch((error) => {
     return { base, allRoutes };
   }
   async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path33.join(this.#app.cwdPath, ".akan", "typecheck");
-    await mkdir7(typecheckDir, { recursive: true });
+    const typecheckDir = path35.join(this.#app.cwdPath, ".akan", "typecheck");
+    await mkdir8(typecheckDir, { recursive: true });
     const tsconfig = {
       extends: "../../tsconfig.json",
       compilerOptions: {
@@ -8444,7 +9027,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path33.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path35.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -8470,10 +9053,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path33.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path33.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path33.join(import.meta.dir, "typecheck.proc.js"),
-      path33.join(import.meta.dir, "typecheck.proc.ts")
+      path35.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path35.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path35.join(import.meta.dir, "typecheck.proc.js"),
+      path35.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -8506,7 +9089,7 @@ void run().catch((error) => {
   }
 }
 // pkgs/@akanjs/devkit/applicationReleasePackager.ts
-import { cp, mkdir as mkdir8, rm as rm3 } from "fs/promises";
+import { cp, mkdir as mkdir9, rm as rm4 } from "fs/promises";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
 import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
@@ -8612,16 +9195,16 @@ class ApplicationReleasePackager {
     const platformVersion = akanConfig2.mobile.version;
     const buildRoot = `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}`;
     if (await FileSys.dirExists(buildRoot))
-      await rm3(buildRoot, { recursive: true, force: true });
-    await mkdir8(buildRoot, { recursive: true });
+      await rm4(buildRoot, { recursive: true, force: true });
+    await mkdir9(buildRoot, { recursive: true });
     if (rebuild || !await FileSys.dirExists(`${this.#app.dist.cwdPath}/backend`))
       await this.#build();
     const buildVersion = `${platformVersion}-${buildNum}`;
     const buildPath = `${buildRoot}/${buildVersion}`;
-    await mkdir8(buildPath, { recursive: true });
+    await mkdir9(buildPath, { recursive: true });
     await cp(`${this.#app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
     await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
-    await rm3(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
+    await rm4(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
     await this.#app.workspace.spawn("tar", [
       "-zcf",
       `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-release.tar.gz`,
@@ -8641,7 +9224,7 @@ class ApplicationReleasePackager {
       `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-appBuild.zip`,
       "./csr"
     ]);
-    await rm3("./csr", { recursive: true, force: true });
+    await rm4("./csr", { recursive: true, force: true });
   }
   async#writeSourceArchive({ readme }) {
     const sourceRoot = `${this.#app.workspace.workspaceRoot}/releases/sources/${this.#app.name}`;
@@ -8649,13 +9232,13 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path34) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path34}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path36) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path36}`;
       if (await FileSys.dirExists(targetPath))
-        await rm3(targetPath, { recursive: true, force: true });
+        await rm4(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path34) => cp(`${this.#app.workspace.cwdPath}/${path34}`, `${sourceRoot}/${path34}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path36) => cp(`${this.#app.workspace.cwdPath}/${path36}`, `${sourceRoot}/${path36}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     await this.#app.workspace.spawn("tar", [
@@ -8671,11 +9254,11 @@ class ApplicationReleasePackager {
       const maxRetry = 3;
       for (let i = 0;i < maxRetry; i++) {
         try {
-          await rm3(sourceRoot, { recursive: true, force: true });
+          await rm4(sourceRoot, { recursive: true, force: true });
         } catch {}
       }
     }
-    await mkdir8(sourceRoot, { recursive: true });
+    await mkdir9(sourceRoot, { recursive: true });
   }
   async#writeSourceTsconfig(sourceRoot, libDeps) {
     const tsconfig = await this.#app.workspace.readJson("tsconfig.json");
@@ -8746,20 +9329,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path34 from "path";
+import path36 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path34.join(path34.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path36.join(path36.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path34.dirname(Bun.main));
+  addResolvedPackageCandidate(path36.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path34.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(path34.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path36.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.join(path36.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path36.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -8768,8 +9351,8 @@ async function resolveSignalTestPreloadPath(target) {
 }
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
-import { mkdir as mkdir9 } from "fs/promises";
-import path35 from "path";
+import { mkdir as mkdir10 } from "fs/promises";
+import path37 from "path";
 var SKIP_ENTRY_DIR_SET = new Set(["node_modules", "dist", "build", ".git", ".next"]);
 var assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
 var assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "file"]));
@@ -8786,14 +9369,14 @@ class Builder {
   #globEntrypoints(cwd, pattern) {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path35.sep);
+      const segments = relativePath.split(path37.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path35.join(cwd, rel));
+    }).map((rel) => path37.join(cwd, rel));
   }
   #globFiles(cwd, pattern = "**/*.*") {
     const glob = new Bun.Glob(pattern);
     return Array.from(glob.scanSync({ cwd, onlyFiles: true })).filter((relativePath) => {
-      const segments = relativePath.split(path35.sep);
+      const segments = relativePath.split(path37.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -8801,17 +9384,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path35.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path37.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path35.isAbsolute(p) ? p : path35.join(cwd, p));
+        out.push(path37.isAbsolute(p) ? p : path37.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path35.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path37.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -8832,9 +9415,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path35.join(cwd, relativePath);
-      const targetPath = path35.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir9(path35.dirname(targetPath), { recursive: true });
+      const sourcePath = path37.join(cwd, relativePath);
+      const targetPath = path37.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path37.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -8845,13 +9428,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path35.posix.parse(withoutFormatDir);
+    const parsed = path37.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path35.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path37.posix.join(parsed.dir, parsed.name);
     const sourcePath = withoutExt.startsWith("./") ? withoutExt.slice(2) : withoutExt;
     const sourceCandidates = [`${sourcePath}.ts`, `${sourcePath}.tsx`];
-    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path35.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path37.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -8900,10 +9483,10 @@ class Builder {
   }
 }
 // pkgs/@akanjs/devkit/capacitorApp.ts
-import { cp as cp2, mkdir as mkdir10, rm as rm4 } from "fs/promises";
-import path36 from "path";
+import { cp as cp2, mkdir as mkdir11, rm as rm5 } from "fs/promises";
+import path38 from "path";
 import { MobileProject } from "@trapezedev/project";
-import { capitalize as capitalize3 } from "akanjs/common";
+import { capitalize as capitalize4 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/fileEditor.ts
 class FileEditor {
@@ -9096,10 +9679,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path36.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path36.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path36.join(this.targetRoot, "www");
-    this.targetAssetRoot = path36.join(this.targetRoot, "assets");
+    this.targetRootPath = path38.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path38.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path38.join(this.targetRoot, "www");
+    this.targetAssetRoot = path38.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -9111,13 +9694,13 @@ class CapacitorApp {
     env = "debug",
     regenerate = false
   } = {}) {
-    await mkdir10(this.targetRoot, { recursive: true });
+    await mkdir11(this.targetRoot, { recursive: true });
     await this.#writeCapacitorConfig();
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm4(path36.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm5(path38.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm4(path36.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm5(path38.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -9181,7 +9764,7 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path36.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path38.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -9224,7 +9807,7 @@ class CapacitorApp {
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path36.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path38.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -9232,10 +9815,10 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir10(path36.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path38.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path36.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path38.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -9281,12 +9864,12 @@ class CapacitorApp {
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path36.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path38.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
-    await rm4(this.targetWebRoot, { recursive: true, force: true });
-    await mkdir10(this.targetWebRoot, { recursive: true });
-    await Bun.write(path36.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await rm5(this.targetWebRoot, { recursive: true, force: true });
+    await mkdir11(this.targetWebRoot, { recursive: true });
+    await Bun.write(path38.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -9297,8 +9880,8 @@ class CapacitorApp {
 </head>`);
   }
   async#writeCapacitorConfig() {
-    await mkdir10(this.targetRoot, { recursive: true });
-    const appInfoPath = path36.relative(this.app.cwdPath, path36.join(this.app.cwdPath, "akan.app.json")).split(path36.sep).join("/");
+    await mkdir11(this.targetRoot, { recursive: true });
+    const appInfoPath = path38.relative(this.app.cwdPath, path38.join(this.app.cwdPath, "akan.app.json")).split(path38.sep).join("/");
     const content = `import type { AppScanResult } from "akanjs";
 import { withBase } from "${process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : ""}akanjs/capacitor.base.config";
 import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
@@ -9319,18 +9902,18 @@ export default withBase(
   appInfo as AppScanResult,
 );
 `;
-    await Bun.write(path36.join(this.app.cwdPath, "capacitor.config.ts"), content);
+    await Bun.write(path38.join(this.app.cwdPath, "capacitor.config.ts"), content);
   }
   async#prepareTargetAssets() {
     if (!this.target.assets)
       return;
-    await mkdir10(this.targetAssetRoot, { recursive: true });
+    await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path36.join(this.app.cwdPath, this.target.assets.icon), path36.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path38.join(this.app.cwdPath, this.target.assets.icon), path38.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path36.join(this.app.cwdPath, this.target.assets.splash), path36.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path38.join(this.app.cwdPath, this.target.assets.splash), path38.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -9338,11 +9921,11 @@ export default withBase(
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path36.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path38.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path36.join(platformRoot, to);
-      await mkdir10(path36.dirname(targetPath), { recursive: true });
-      await cp2(path36.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path38.join(platformRoot, to);
+      await mkdir11(path38.dirname(targetPath), { recursive: true });
+      await cp2(path38.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -9352,7 +9935,7 @@ export default withBase(
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path36.posix.join(this.targetRootPath, "assets"),
+      path38.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -9454,7 +10037,7 @@ export default withBase(
     this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
   }
   async#setPermissionInIos(permissions) {
-    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize3(key)}`, value]));
+    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize4(key)}`, value]));
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
@@ -9539,15 +10122,15 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path37 from "path";
+import path39 from "path";
 import { confirm, input as input2, select as select2 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
 import { program } from "commander";
 
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
-var capitalize4 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
-var createDependencyKey = (refName, kind) => `${refName}${capitalize4(kind)}`;
+var capitalize5 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize5(kind)}`;
 
 class CommandContainer {
   static #instances = new Map;
@@ -10039,7 +10622,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path37.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path39.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -10317,8 +10900,8 @@ var scanModuleSpecifiers = (source, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts7.readConfigFile(tsConfigPath, (path38) => {
-    return ts7.sys.readFile(path38);
+  const configFile = ts7.readConfigFile(tsConfigPath, (path40) => {
+    return ts7.sys.readFile(path40);
   });
   return ts7.parseJsonConfigFileContent(configFile.config, ts7.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
@@ -10560,7 +11143,6 @@ import { jsxDEV as jsxDEV2, Fragment as Fragment2 } from "react/jsx-dev-runtime"
 "use client";
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
 import { Logger as Logger11 } from "akanjs/common";
-
 class IncrementalBuilder {
   #logger = new Logger11("IncrementalBuilder");
   #app;
@@ -10569,6 +11151,8 @@ class IncrementalBuilder {
   #cssCompiler;
   #optimizedFonts;
   #discovery;
+  #changePlanner;
+  #generatedIndexSync;
   #generation = 0;
   #workQueue = Promise.resolve();
   #cssRebuildQueue = Promise.resolve();
@@ -10581,6 +11165,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) {
     return this.#enqueueWork(`build-route:${msg.routeId}`, async () => this.#handleBuildRoute(msg));
@@ -10596,6 +11182,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,
@@ -10614,9 +11201,24 @@ 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, { generation, ok, files, message }) {
+    if (typeof generation !== "number")
+      return;
+    process.send?.({
+      type: "build-status",
+      data: {
+        generation,
+        phase,
+        ok,
+        files: files ?? [],
+        message
+      }
+    });
+  }
   async#enqueueWork(label, fn) {
     const started = Date.now();
     const run = this.#workQueue.then(fn, fn);
@@ -10632,10 +11234,10 @@ class IncrementalBuilder {
     }
   }
   batchTouchesPagesTree(appDir, batch) {
-    const absAppDir = path38.resolve(appDir);
+    const absAppDir = path40.resolve(appDir);
     for (const f of batch.files) {
-      const abs = path38.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path38.sep}`) && abs !== absAppDir)
+      const abs = path40.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path40.sep}`) && abs !== absAppDir)
         continue;
       if (/\.(tsx|ts|jsx|js)$/.test(abs))
         return true;
@@ -10643,15 +11245,15 @@ class IncrementalBuilder {
     return false;
   }
   async batchMayChangePageKeys(appDir, batch) {
-    const absAppDir = path38.resolve(appDir);
-    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path38.normalize(key)));
+    const absAppDir = path40.resolve(appDir);
+    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path40.normalize(key)));
     for (const f of batch.files) {
-      const abs = path38.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path38.sep}`) && abs !== absAppDir)
+      const abs = path40.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path40.sep}`) && abs !== absAppDir)
         continue;
       if (!/\.(tsx|ts|jsx|js)$/.test(abs))
         continue;
-      const rel = path38.normalize(path38.relative(absAppDir, abs));
+      const rel = path40.normalize(path40.relative(absAppDir, abs));
       if (!await Bun.file(abs).exists() || !pageKeys.has(rel))
         return true;
     }
@@ -10679,7 +11281,7 @@ class IncrementalBuilder {
 ${cssText}`).toString(36);
           const cssRelPath = `styles/${cssAssetName}-${cssHash}.css`;
           const cssUrl = `/_akan/styles/${cssAssetName}-${cssHash}.css`;
-          await Bun.write(path38.join(artifactDir, cssRelPath), cssText);
+          await Bun.write(path40.join(artifactDir, cssRelPath), cssText);
           cssAssetEntries.push([basePath2, { cssUrl, cssRelPath }]);
           cssBase64ByUrl[cssUrl] = Buffer.from(new TextEncoder().encode(cssText)).toString("base64");
         })()
@@ -10719,9 +11321,17 @@ ${cssText}`).toString(36);
           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);
   }
@@ -10739,10 +11349,10 @@ ${cssText}`).toString(36);
     if (changedFiles.length === 0)
       return false;
     return changedFiles.some((file) => {
-      const normalized = path38.resolve(file);
+      const normalized = path40.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
         return true;
-      return this.#optimizedFonts.files.some((fontFile) => path38.resolve(fontFile) === normalized);
+      return this.#optimizedFonts.files.some((fontFile) => path40.resolve(fontFile) === normalized);
     });
   }
   async installWatcher() {
@@ -10759,38 +11369,58 @@ ${cssText}`).toString(36);
     this.#logger.verbose(`watching ${roots.length} roots`);
   }
   async#handleWatchBatch(appDir, artifactDir, batch) {
-    const kinds = [...batch.kinds];
-    if (kinds.length === 0)
+    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);
+        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(`
+`) });
+      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");
     }
     if (kinds.includes("code") && this.#shouldRebuildCsr()) {
       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 = { type: "invalidate", kinds, files: batch.files, generation };
     process.send?.(event);
     if (kinds.includes("code")) {
       try {
@@ -10798,15 +11428,18 @@ ${cssText}`).toString(36);
         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}`);
     }
   }