@akanjs/cli 2.3.13 → 2.4.0-rc.1

package/incrementalBuilder.proc.js

@@ -2,7 +2,7 @@
 var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import path44 from "path";
+import path45 from "path";
 
 // pkgs/@akanjs/devkit/aiEditor.ts
 import { input, select } from "@inquirer/prompts";
@@ -4287,9 +4287,10 @@ class IncrementalBuilderHost {
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
 var backendMsgTypeSet = new Set(["build-route"]);
 var BACKEND_RESTART_DEBOUNCE_MS = 120;
-var BACKEND_GRACEFUL_TIMEOUT_MS = 3000;
+var BACKEND_GRACEFUL_TIMEOUT_MS = 8000;
 var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
 var BACKEND_RECOVERY_MAX_DELAY_MS = 30000;
+var BACKEND_RECOVERY_MAX_ATTEMPTS = 5;
 var BACKEND_STDERR_TAIL_LIMIT = 40;
 var BUILDER_READY_TIMEOUT_MS = 150000;
 var BUILDER_START_MAX_ATTEMPTS = 3;
@@ -4314,6 +4315,8 @@ var shouldRestartBackendByDevPlan = (message) => {
   return message.devPlan.actions.includes("restart-backend");
 };
 var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includes("restart-builder") ?? false;
+var shouldAbandonBackendRecovery = (attempts, maxAttempts = BACKEND_RECOVERY_MAX_ATTEMPTS) => attempts >= maxAttempts;
+var normalizeBackendReportedGeneration = (generation) => generation >= 0 ? generation : undefined;
 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;
@@ -4562,6 +4565,16 @@ class AkanAppHost {
           this.#replayBuilderState();
           return;
         }
+        if (msg.type === "build-status") {
+          const status = this.#recordBackendBuildStatus({
+            generation: normalizeBackendReportedGeneration(msg.data.generation),
+            ok: msg.data.ok,
+            files: msg.data.files,
+            message: msg.data.message
+          });
+          this.#sendOrQueueBuildStatus(status);
+          return;
+        }
         if (backendMsgTypeSet.has(msg.type))
           this.#sendToBuilder(msg);
       },
@@ -4723,6 +4736,19 @@ class AkanAppHost {
   #scheduleBackendRecovery(reason) {
     if (this.#backendRecoveryTimer || this.#backend)
       return;
+    if (shouldAbandonBackendRecovery(this.#backendRecoveryAttempts)) {
+      const message = `Backend exited ${this.#backendRecoveryAttempts} times in a row (${reason}); waiting for a server-side edit to retry.`;
+      this.#setBackendLifecycleState("stopped", `gave up after ${this.#backendRecoveryAttempts} recovery attempts`);
+      this.logger.error(`[backend-recovery] ${message}`);
+      if (this.#backendStderrTail.length > 0) {
+        this.logger.error(`[backend-recovery] recent backend stderr:
+${this.#backendStderrTail.join(`
+`)}`);
+      }
+      const abandonedStatus = this.#recordBackendBuildStatus({ ok: false, files: [], message });
+      this.#sendOrQueueBuildStatus(abandonedStatus);
+      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);
@@ -4771,6 +4797,7 @@ ${this.#backendStderrTail.join(`
     this.#sendToBackend(message);
   }
   async#handleInvalidate(message) {
+    this.#logDevPlan(message);
     if (shouldRestartBuilderByDevPlan(message)) {
       try {
         await this.#restartDevChildren(message);
@@ -4882,12 +4909,16 @@ ${this.#backendStderrTail.join(`
       this.#sendToBackend({ type: "build-status", data: status });
     }
   }
+  #logDevPlan(message) {
+    if (!message.devPlan)
+      return;
+    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}`);
+  }
   async#shouldRestartBackend(message) {
     if (message.kinds.length === 1 && message.kinds[0] === "css")
       return false;
     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();
@@ -8837,7 +8868,7 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
 }
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import { mkdir as mkdir8, rm as rm4 } from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
 import path22 from "path";
@@ -10620,14 +10651,538 @@ class AllRoutesBuilder {
     this.#routeIds.push(routeId);
   }
 }
+// pkgs/@akanjs/devkit/frontendBuild/autoImportSync.ts
+import { readdir as readdir2, readFile, stat as stat3, writeFile } from "fs/promises";
+import path23 from "path";
+import ts8 from "typescript";
+var TEST_FILE_RE = /\.(test|spec)\.(ts|tsx)$/;
+var AKAN_BASE = {
+  names: ["Int", "Float", "ID", "Any", "Upload", "enumOf", "dayjs"],
+  specifier: "akanjs/base",
+  kind: "named"
+};
+var AKAN_BASE_TYPES = { names: ["Dayjs"], specifier: "akanjs/base", kind: "named", typeOnly: true };
+var CNST_NS = { names: ["cnst"], specifier: "../cnst", kind: "namespace" };
+var DB_NS = { names: ["db"], specifier: "../db", kind: "namespace" };
+var SRV_NS = { names: ["srv"], specifier: "../srv", kind: "namespace" };
+var ERR_DICT = { names: ["Err"], specifier: "../dict", kind: "named" };
+var RULES = {
+  constant: [AKAN_BASE, AKAN_BASE_TYPES, { names: ["via"], specifier: "akanjs/constant", kind: "named" }],
+  document: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    CNST_NS,
+    DB_NS,
+    ERR_DICT,
+    {
+      names: ["by", "from", "into", "SchemaOf", "DataInputOf", "DocumentUpdateHelper", "documentQueryHelper", "Mdl"],
+      specifier: "akanjs/document",
+      kind: "named"
+    }
+  ],
+  service: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    DB_NS,
+    SRV_NS,
+    CNST_NS,
+    ERR_DICT,
+    { names: ["serve"], specifier: "akanjs/service", kind: "named" },
+    {
+      names: ["DataInputOf", "ListQueryOption", "DatabaseRegistry", "getFilterInfoByKey"],
+      specifier: "akanjs/document",
+      kind: "named"
+    }
+  ],
+  signal: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    SRV_NS,
+    CNST_NS,
+    ERR_DICT,
+    {
+      names: ["endpoint", "internal", "slice", "Public", "Req", "Ws", "None", "Res"],
+      specifier: "akanjs/signal",
+      kind: "named"
+    }
+  ],
+  dictionary: [
+    {
+      names: ["modelDictionary", "scalarDictionary", "serviceDictionary"],
+      specifier: "akanjs/dictionary",
+      kind: "named"
+    }
+  ],
+  srvkit: [
+    AKAN_BASE,
+    AKAN_BASE_TYPES,
+    { names: ["Logger", "HttpClient", "sleep"], specifier: "akanjs/common", kind: "named" },
+    { names: ["adapt"], specifier: "akanjs/service", kind: "named" },
+    { names: ["SignalContext", "Guard", "InternalArg", "Middleware"], specifier: "akanjs/signal", kind: "named" }
+  ],
+  common: [AKAN_BASE, AKAN_BASE_TYPES],
+  store: [
+    CNST_NS,
+    { names: ["store"], specifier: "akanjs/store", kind: "named" },
+    { names: ["fetch", "usePage", "sig"], specifier: "../useClient", kind: "named" },
+    { names: ["st"], specifier: "../st", kind: "named" },
+    { names: ["RootStore"], specifier: "../st", kind: "named", typeOnly: true }
+  ],
+  client: [
+    {
+      names: ["cnst", "fetch", "st", "usePage"],
+      specifier: (ctx) => `@${ctx.scope}/${ctx.project}/client`,
+      kind: "named"
+    }
+  ]
+};
+var PASCAL_CASE_RE = /^[A-Z][A-Za-z0-9]*$/;
+var DOMAIN_ROLE_KINDS = {
+  constant: ["constant"],
+  dictionary: ["constant", "document", "signal"],
+  common: ["constant"]
+};
+var LIB_BARRELS = {
+  Err: { barrel: "dict", kind: "named" },
+  db: { barrel: "db", kind: "namespace" },
+  cnst: { barrel: "cnst", kind: "namespace" },
+  srv: { barrel: "srv", kind: "namespace" }
+};
+var DOMAIN_DENYLIST = new Set([
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Date",
+  "Promise",
+  "Array",
+  "Object",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "RegExp",
+  "Symbol",
+  "Proxy",
+  "Reflect",
+  "JSON",
+  "Math",
+  "Number",
+  "BigInt",
+  "Function",
+  "Boolean",
+  "String",
+  "Record",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit",
+  "Exclude",
+  "Extract",
+  "NonNullable",
+  "ReturnType",
+  "Parameters",
+  "Awaited",
+  "InstanceType"
+]);
+
+class AutoImportSync {
+  #workspaceRoot;
+  #domainCache = new Map;
+  constructor({ workspaceRoot }) {
+    this.#workspaceRoot = path23.resolve(workspaceRoot);
+  }
+  async syncForBatch(files) {
+    const changedFiles = [];
+    const errors = [];
+    const seen = new Set;
+    for (const file of files) {
+      const pkgRoot = this.#domainPkgRootOf(file);
+      if (pkgRoot)
+        this.#domainCache.delete(pkgRoot);
+    }
+    for (const file of files) {
+      const abs = path23.resolve(file);
+      if (seen.has(abs))
+        continue;
+      seen.add(abs);
+      const ctx = this.#contextFor(abs);
+      if (!ctx)
+        continue;
+      try {
+        const changed = await this.#syncFile(abs, ctx);
+        if (changed)
+          changedFiles.push(abs);
+      } catch (err) {
+        errors.push(`[auto-import] sync failed for ${file}: ${formatError(err)}`);
+      }
+    }
+    return { changedFiles, errors };
+  }
+  #contextFor(abs) {
+    const rel = path23.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path23.isAbsolute(rel))
+      return null;
+    const base = path23.basename(abs);
+    if (TEST_FILE_RE.test(base) || base === "index.ts" || base === "index.tsx" || base.endsWith(".d.ts"))
+      return null;
+    const parts = rel.split(path23.sep).filter(Boolean);
+    const [scope, project, facet] = parts;
+    if (scope !== "apps" && scope !== "libs" || !project || !facet)
+      return null;
+    const role = roleFor(facet, base);
+    if (!role)
+      return null;
+    return { role, scope, project };
+  }
+  async#syncFile(abs, ctx) {
+    const stats = await stat3(abs).catch(() => null);
+    if (!stats?.isFile())
+      return false;
+    const source2 = await readFile(abs, "utf8");
+    const resolveExtra = await this.#extraResolverFor(abs, ctx);
+    const next = transformSource(source2, abs, ctx, resolveExtra);
+    if (next === null || next === source2)
+      return false;
+    await writeFile(abs, next);
+    return true;
+  }
+  async#extraResolverFor(abs, ctx) {
+    const resolvers = [];
+    if (ctx.role === "srvkit" || ctx.role === "common")
+      resolvers.push(await this.#libBarrelResolver(abs, ctx));
+    const kinds = DOMAIN_ROLE_KINDS[ctx.role];
+    if (kinds)
+      resolvers.push(await this.#domainResolver(abs, ctx, kinds));
+    if (resolvers.length === 0)
+      return;
+    return (symbol) => {
+      for (const resolve of resolvers) {
+        const target = resolve(symbol);
+        if (target)
+          return target;
+      }
+      return null;
+    };
+  }
+  async#domainResolver(abs, ctx, kinds) {
+    const index = await this.#domainIndex(path23.join(this.#workspaceRoot, ctx.scope, ctx.project));
+    const fileDir = path23.dirname(abs);
+    return (symbol) => {
+      if (!PASCAL_CASE_RE.test(symbol) || DOMAIN_DENYLIST.has(symbol))
+        return null;
+      const entries = (index.get(symbol) ?? []).filter((entry) => kinds.includes(entry.kind));
+      if (entries.length !== 1)
+        return null;
+      return { specifier: relativeSpecifier(fileDir, entries[0].file), kind: "named" };
+    };
+  }
+  async#libBarrelResolver(abs, ctx) {
+    const fileDir = path23.dirname(abs);
+    const libDir = path23.join(this.#workspaceRoot, ctx.scope, ctx.project, "lib");
+    const available = new Map;
+    for (const [symbol, { barrel, kind }] of Object.entries(LIB_BARRELS)) {
+      if (await fileExists2(path23.join(libDir, `${barrel}.ts`)))
+        available.set(symbol, { specifier: relativeSpecifier(fileDir, path23.join(libDir, barrel)), kind });
+    }
+    return (symbol) => available.get(symbol) ?? null;
+  }
+  async#domainIndex(pkgRoot) {
+    const cached = this.#domainCache.get(pkgRoot);
+    if (cached)
+      return cached;
+    const index = await buildDomainIndex(path23.join(pkgRoot, "lib"));
+    this.#domainCache.set(pkgRoot, index);
+    return index;
+  }
+  #domainPkgRootOf(file) {
+    const rel = path23.relative(this.#workspaceRoot, path23.resolve(file));
+    if (rel.startsWith("..") || path23.isAbsolute(rel))
+      return null;
+    const [scope, project, facet] = rel.split(path23.sep).filter(Boolean);
+    if (scope !== "apps" && scope !== "libs" || !project || facet !== "lib")
+      return null;
+    if (!domainKindOf(path23.basename(file)))
+      return null;
+    return path23.join(this.#workspaceRoot, scope, project);
+  }
+}
+var roleFor = (facet, base) => {
+  if (facet === "lib") {
+    if (base.endsWith(".constant.ts"))
+      return "constant";
+    if (base.endsWith(".document.ts"))
+      return "document";
+    if (base.endsWith(".service.ts"))
+      return "service";
+    if (base.endsWith(".signal.ts"))
+      return "signal";
+    if (base.endsWith(".dictionary.ts"))
+      return "dictionary";
+    if (base.endsWith(".store.ts"))
+      return "store";
+    if (base.endsWith(".tsx"))
+      return "client";
+    return null;
+  }
+  if (facet === "ui" || facet === "page")
+    return base.endsWith(".tsx") ? "client" : null;
+  if (facet === "webkit")
+    return base.endsWith(".ts") || base.endsWith(".tsx") ? "client" : null;
+  if (facet === "srvkit")
+    return base.endsWith(".ts") ? "srvkit" : null;
+  if (facet === "common")
+    return base.endsWith(".ts") || base.endsWith(".tsx") ? "common" : null;
+  return null;
+};
+var targetFor = (symbol, ctx) => {
+  for (const rule of RULES[ctx.role]) {
+    if (!rule.names.includes(symbol))
+      continue;
+    const specifier = typeof rule.specifier === "function" ? rule.specifier(ctx) : rule.specifier;
+    return { specifier, kind: rule.kind, typeOnly: rule.typeOnly };
+  }
+  return null;
+};
+var transformSource = (source2, fileName, ctx, resolveExtra) => {
+  const sf = ts8.createSourceFile(fileName, source2, ts8.ScriptTarget.Latest, true, scriptKindFor(fileName));
+  const bound = collectBoundNames(sf);
+  const used = collectUsedReferences(sf);
+  const namedBySpecifier = new Map;
+  const namespaceImports = [];
+  for (const name of used) {
+    if (bound.has(name))
+      continue;
+    const target = targetFor(name, ctx) ?? resolveExtra?.(name) ?? null;
+    if (!target)
+      continue;
+    if (target.kind === "namespace")
+      namespaceImports.push({ name, specifier: target.specifier });
+    else {
+      const names = namedBySpecifier.get(target.specifier) ?? new Map;
+      names.set(name, target.typeOnly ?? false);
+      namedBySpecifier.set(target.specifier, names);
+    }
+  }
+  if (namedBySpecifier.size === 0 && namespaceImports.length === 0)
+    return null;
+  const importDecls = sf.statements.filter(ts8.isImportDeclaration);
+  const anchor = importDecls.at(-1) ?? null;
+  const namedImportsBySpecifier = collectExistingNamedImports(importDecls);
+  const edits = [];
+  const newStatements = [];
+  for (const [specifier, names] of namedBySpecifier) {
+    const existing = namedImportsBySpecifier.get(specifier);
+    if (existing) {
+      const merged = new Map(existing.names);
+      for (const [name, isType] of names)
+        if (!merged.has(name))
+          merged.set(name, isType);
+      edits.push({
+        start: existing.decl.getStart(sf),
+        end: existing.decl.getEnd(),
+        text: formatNamedImport(specifier, merged)
+      });
+    } else
+      newStatements.push(formatNamedImport(specifier, names));
+  }
+  for (const ns of namespaceImports)
+    newStatements.push(`import * as ${ns.name} from "${ns.specifier}";`);
+  if (newStatements.length > 0) {
+    const anchorEdit = anchor ? edits.find((edit) => edit.start === anchor.getStart(sf)) : undefined;
+    if (anchorEdit)
+      anchorEdit.text = `${anchorEdit.text}
+${newStatements.join(`
+`)}`;
+    else if (anchor)
+      edits.push({ start: anchor.getEnd(), end: anchor.getEnd(), text: `
+${newStatements.join(`
+`)}` });
+    else {
+      const prologueEnd = directivePrologueEnd(sf);
+      if (prologueEnd >= 0)
+        edits.push({ start: prologueEnd, end: prologueEnd, text: `
+${newStatements.join(`
+`)}` });
+      else
+        edits.push({ start: 0, end: 0, text: `${newStatements.join(`
+`)}
+
+` });
+    }
+  }
+  if (edits.length === 0)
+    return null;
+  edits.sort((a, b) => b.start - a.start);
+  let out = source2;
+  for (const edit of edits)
+    out = out.slice(0, edit.start) + edit.text + out.slice(edit.end);
+  return out === source2 ? null : out;
+};
+var collectBoundNames = (sf) => {
+  const names = new Set;
+  const visit = (node) => {
+    if (ts8.isImportClause(node)) {
+      if (node.name)
+        names.add(node.name.text);
+      const bindings = node.namedBindings;
+      if (bindings && ts8.isNamespaceImport(bindings))
+        names.add(bindings.name.text);
+      if (bindings && ts8.isNamedImports(bindings))
+        for (const el of bindings.elements)
+          names.add(el.name.text);
+    }
+    if ((ts8.isVariableDeclaration(node) || ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node) || ts8.isParameter(node) || ts8.isBindingElement(node) || ts8.isEnumDeclaration(node) || ts8.isTypeAliasDeclaration(node) || ts8.isInterfaceDeclaration(node)) && node.name && ts8.isIdentifier(node.name))
+      names.add(node.name.text);
+    ts8.forEachChild(node, visit);
+  };
+  ts8.forEachChild(sf, visit);
+  return names;
+};
+var collectUsedReferences = (sf) => {
+  const used = new Set;
+  const visit = (node) => {
+    if (ts8.isIdentifier(node) && isReferencePosition(node))
+      used.add(node.text);
+    ts8.forEachChild(node, visit);
+  };
+  ts8.forEachChild(sf, visit);
+  return used;
+};
+var isReferencePosition = (node) => {
+  const parent = node.parent;
+  if (!parent)
+    return true;
+  if (ts8.isPropertyAccessExpression(parent) && parent.name === node)
+    return false;
+  if (ts8.isQualifiedName(parent) && parent.right === node)
+    return false;
+  if (ts8.isPropertyAssignment(parent) && parent.name === node)
+    return false;
+  if (ts8.isPropertySignature(parent) && parent.name === node)
+    return false;
+  if (ts8.isBindingElement(parent) && parent.propertyName === node)
+    return false;
+  if (ts8.isImportSpecifier(parent) || ts8.isExportSpecifier(parent))
+    return false;
+  return true;
+};
+var collectExistingNamedImports = (importDecls) => {
+  const map = new Map;
+  for (const decl of importDecls) {
+    const clause = decl.importClause;
+    const bindings = clause?.namedBindings;
+    if (!clause || !bindings || !ts8.isNamedImports(bindings))
+      continue;
+    if (!ts8.isStringLiteral(decl.moduleSpecifier))
+      continue;
+    const specifier = decl.moduleSpecifier.text;
+    if (map.has(specifier))
+      continue;
+    const names = new Map;
+    for (const el of bindings.elements)
+      names.set(el.name.text, clause.isTypeOnly || el.isTypeOnly);
+    map.set(specifier, { decl, names });
+  }
+  return map;
+};
+var formatNamedImport = (specifier, names) => {
+  const entries = [...names.entries()].sort((a, b) => compareNames(a[0], b[0]));
+  if (entries.every(([, isType]) => isType))
+    return `import type { ${entries.map(([name]) => name).join(", ")} } from "${specifier}";`;
+  const parts = entries.map(([name, isType]) => isType ? `type ${name}` : name);
+  return `import { ${parts.join(", ")} } from "${specifier}";`;
+};
+var directivePrologueEnd = (sf) => {
+  let end = -1;
+  for (const stmt of sf.statements) {
+    if (ts8.isExpressionStatement(stmt) && ts8.isStringLiteral(stmt.expression))
+      end = stmt.getEnd();
+    else
+      break;
+  }
+  return end;
+};
+var scriptKindFor = (fileName) => fileName.endsWith(".tsx") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS;
+var compareNames = (a, b) => {
+  const [la, lb] = [a.toLowerCase(), b.toLowerCase()];
+  if (la !== lb)
+    return la < lb ? -1 : 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+};
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+var fileExists2 = async (file) => stat3(file).then((s) => s.isFile()).catch(() => false);
+var domainKindOf = (base) => {
+  if (base.endsWith(".constant.ts"))
+    return "constant";
+  if (base.endsWith(".document.ts"))
+    return "document";
+  if (base.endsWith(".signal.ts"))
+    return "signal";
+  return null;
+};
+var buildDomainIndex = async (libDir) => {
+  const index = new Map;
+  for (const file of await collectDomainFiles(libDir)) {
+    const kind = domainKindOf(path23.basename(file));
+    if (!kind)
+      continue;
+    const src = await readFile(file, "utf8").catch(() => null);
+    if (src === null)
+      continue;
+    for (const name of exportedPascalNames(src, file)) {
+      const entries = index.get(name) ?? [];
+      entries.push({ file, kind });
+      index.set(name, entries);
+    }
+  }
+  return index;
+};
+var collectDomainFiles = async (dir) => {
+  const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules")
+      continue;
+    const full = path23.join(dir, entry.name);
+    if (entry.isDirectory())
+      files.push(...await collectDomainFiles(full));
+    else if (domainKindOf(entry.name) && !TEST_FILE_RE.test(entry.name))
+      files.push(full);
+  }
+  return files;
+};
+var exportedPascalNames = (source2, fileName) => {
+  const sf = ts8.createSourceFile(fileName, source2, ts8.ScriptTarget.Latest, true);
+  const isExported = (node) => ts8.canHaveModifiers(node) && (ts8.getModifiers(node) ?? []).some((m) => m.kind === ts8.SyntaxKind.ExportKeyword);
+  const names = [];
+  for (const stmt of sf.statements) {
+    if ((ts8.isClassDeclaration(stmt) || ts8.isFunctionDeclaration(stmt) || ts8.isEnumDeclaration(stmt)) && stmt.name) {
+      if (isExported(stmt))
+        names.push(stmt.name.text);
+    } else if (ts8.isVariableStatement(stmt) && isExported(stmt)) {
+      for (const decl of stmt.declarationList.declarations)
+        if (ts8.isIdentifier(decl.name))
+          names.push(decl.name.text);
+    } else if (ts8.isExportDeclaration(stmt) && stmt.exportClause && ts8.isNamedExports(stmt.exportClause)) {
+      for (const el of stmt.exportClause.elements)
+        names.push(el.name.text);
+    }
+  }
+  return names.filter((name) => PASCAL_CASE_RE.test(name));
+};
+var relativeSpecifier = (fromDir, toFile) => {
+  const rel = path23.relative(fromDir, toFile).replace(/\.tsx?$/, "").split(path23.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
 // pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
 import { mkdir as mkdir5, rm as rm2, unlink } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
 import fs3 from "fs";
-import path23 from "path";
-import ts8 from "typescript";
+import path24 from "path";
+import ts9 from "typescript";
 
 class PagesEntrySourceGenerator {
   #pageEntries;
@@ -10669,12 +11224,12 @@ ${entries.join(`
 `;
   }
   static #toImportSpecifier(moduleAbsPath) {
-    return path23.resolve(moduleAbsPath).split(path23.sep).join("/");
+    return path24.resolve(moduleAbsPath).split(path24.sep).join("/");
   }
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
-      const source2 = fs3.readFileSync(path23.resolve(moduleAbsPath), "utf8");
-      const sourceFile2 = ts8.createSourceFile(moduleAbsPath, source2, ts8.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
+      const source2 = fs3.readFileSync(path24.resolve(moduleAbsPath), "utf8");
+      const sourceFile2 = ts9.createSourceFile(moduleAbsPath, source2, ts9.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
       return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile2);
     } catch {
       return false;
@@ -10684,31 +11239,31 @@ ${entries.join(`
     const asyncBindings = new Map;
     let defaultIdentifier = null;
     for (const statement of sourceFile2.statements) {
-      if (ts8.isFunctionDeclaration(statement)) {
-        if (PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.DefaultKeyword)) {
-          return PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.AsyncKeyword);
+      if (ts9.isFunctionDeclaration(statement)) {
+        if (PagesEntrySourceGenerator.#hasModifier(statement, ts9.SyntaxKind.DefaultKeyword)) {
+          return PagesEntrySourceGenerator.#hasModifier(statement, ts9.SyntaxKind.AsyncKeyword);
         }
         if (statement.name) {
-          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts8.SyntaxKind.AsyncKeyword));
+          asyncBindings.set(statement.name.text, PagesEntrySourceGenerator.#hasModifier(statement, ts9.SyntaxKind.AsyncKeyword));
         }
         continue;
       }
-      if (ts8.isVariableStatement(statement)) {
+      if (ts9.isVariableStatement(statement)) {
         for (const declaration of statement.declarationList.declarations) {
-          if (!ts8.isIdentifier(declaration.name))
+          if (!ts9.isIdentifier(declaration.name))
             continue;
           asyncBindings.set(declaration.name.text, PagesEntrySourceGenerator.#isAsyncFunctionExpression(declaration.initializer));
         }
         continue;
       }
-      if (ts8.isExportAssignment(statement)) {
+      if (ts9.isExportAssignment(statement)) {
         if (PagesEntrySourceGenerator.#isAsyncFunctionExpression(statement.expression))
           return true;
-        if (ts8.isIdentifier(statement.expression))
+        if (ts9.isIdentifier(statement.expression))
           defaultIdentifier = statement.expression.text;
         continue;
       }
-      if (ts8.isExportDeclaration(statement) && statement.exportClause && ts8.isNamedExports(statement.exportClause)) {
+      if (ts9.isExportDeclaration(statement) && statement.exportClause && ts9.isNamedExports(statement.exportClause)) {
         const exportClause = statement.exportClause;
         for (const specifier of exportClause.elements) {
           if (specifier.name.text !== "default")
@@ -10720,13 +11275,13 @@ ${entries.join(`
     return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
   }
   static #hasModifier(node, kind) {
-    return ts8.canHaveModifiers(node) && (ts8.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+    return ts9.canHaveModifiers(node) && (ts9.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
   }
   static #isAsyncFunctionExpression(node) {
-    return Boolean(node && (ts8.isArrowFunction(node) || ts8.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts8.SyntaxKind.AsyncKeyword));
+    return Boolean(node && (ts9.isArrowFunction(node) || ts9.isFunctionExpression(node)) && PagesEntrySourceGenerator.#hasModifier(node, ts9.SyntaxKind.AsyncKeyword));
   }
   static #scriptKind(moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts8.ScriptKind.TSX : ts8.ScriptKind.TS;
+    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? ts9.ScriptKind.TSX : ts9.ScriptKind.TS;
   }
 }
 
@@ -10752,7 +11307,7 @@ class CsrArtifactBuilder {
     const csrBasePaths = [...akanConfig2.basePaths];
     const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
     await rm2(this.#outputDir, { recursive: true, force: true });
-    await mkdir5(path24.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
+    await mkdir5(path25.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
     const generatedHtmlFiles = Object.fromEntries(htmlEntries.map((basePath2) => this.#createHtmlFile(basePath2)));
     const result = await Bun.build({
       target: "browser",
@@ -10784,7 +11339,7 @@ ${logs}` : ""}`);
     return { outputDir: this.#outputDir };
   }
   get #outputDir() {
-    return path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+    return path25.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
   }
   #define() {
     const nodeEnv = this.#command === "build" ? "production" : "development";
@@ -10815,8 +11370,8 @@ ${logs}` : ""}`);
     ];
   }
   async#loadCsrArtifact() {
-    const artifactDir = path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-    const artifactFile = Bun.file(path24.join(artifactDir, "base-artifact.json"));
+    const artifactDir = path25.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+    const artifactFile = Bun.file(path25.join(artifactDir, "base-artifact.json"));
     if (!await artifactFile.exists())
       return { cssAssets: {} };
     const artifact = await artifactFile.json();
@@ -10829,7 +11384,7 @@ ${logs}` : ""}`);
       const htmlFile = Bun.file(htmlPath);
       if (!await htmlFile.exists())
         continue;
-      const basePath2 = path24.basename(htmlPath, ".html") === "index" ? "" : path24.basename(htmlPath, ".html");
+      const basePath2 = path25.basename(htmlPath, ".html") === "index" ? "" : path25.basename(htmlPath, ".html");
       const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath2]);
       for (const filePath of inlined.jsFiles)
         jsFiles.add(filePath);
@@ -10871,7 +11426,7 @@ ${remainingAssets.join(`
         next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
     }
     if (cssAsset) {
-      const cssPath = path24.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
+      const cssPath = path25.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
       const css = await Bun.file(cssPath).text();
       const style = CsrArtifactBuilder.createInlineStyle(css);
       if (!next.includes(style))
@@ -10942,16 +11497,16 @@ ${CsrArtifactBuilder.escapeInlineScript(await loadScript(src))}
       throw new Error(`[csr-build] cannot inline external script: ${src}`);
     }
     const normalized = src.startsWith("/") ? src.slice(1) : src;
-    return path24.resolve(path24.dirname(htmlPath), normalized);
+    return path25.resolve(path25.dirname(htmlPath), normalized);
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path26 from "path";
+import path27 from "path";
 import { Logger as Logger8 } from "akanjs/common";
 import { compile } from "tailwindcss";
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path25 from "path";
+import path26 from "path";
 var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
 
 class CssImportResolver {
@@ -11004,7 +11559,7 @@ class CssImportResolver {
     const exact = this.#paths[id];
     if (exact) {
       for (const repl of exact) {
-        const resolved = await this.#firstExisting(path25.resolve(this.#workspaceRoot, repl));
+        const resolved = await this.#firstExisting(path26.resolve(this.#workspaceRoot, repl));
         if (resolved)
           return resolved;
       }
@@ -11015,7 +11570,7 @@ class CssImportResolver {
       const suffix = id.slice(prefix.length);
       for (const repl of replacements) {
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const resolved = await this.#firstExisting(path25.resolve(this.#workspaceRoot, replPath + suffix));
+        const resolved = await this.#firstExisting(path26.resolve(this.#workspaceRoot, replPath + suffix));
         if (resolved)
           return resolved;
       }
@@ -11045,25 +11600,25 @@ class CssImportResolver {
     try {
       if (!await Bun.file(pkgPath).exists())
         return null;
-      const pkgDir = path25.dirname(pkgPath);
+      const pkgDir = path26.dirname(pkgPath);
       const pkg = await Bun.file(pkgPath).json();
       const subpath = id === pkgName ? "." : `.${id.slice(pkgName.length)}`;
       const exportValue = pkg.exports?.[subpath];
       const styleEntry = (typeof exportValue === "string" ? exportValue : exportValue?.style || exportValue?.import || exportValue?.default) || pkg.exports?.["."]?.style || pkg.style || "index.css";
-      return await this.#firstExisting(path25.resolve(pkgDir, styleEntry));
+      return await this.#firstExisting(path26.resolve(pkgDir, styleEntry));
     } catch {
       return null;
     }
   }
   #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path25.dirname(Bun.main), path25.resolve(path25.dirname(Bun.main), "../..")];
+    return [fromBase, this.#workspaceRoot, path26.dirname(Bun.main), path26.resolve(path26.dirname(Bun.main), "../..")];
   }
   #packageJsonCandidates(pkgName) {
     return [
-      path25.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
-      path25.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
-      path25.join(path25.dirname(Bun.main), "node_modules", pkgName, "package.json"),
-      path25.join(path25.dirname(Bun.main), "../../", pkgName, "package.json")
+      path26.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path26.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path26.join(path26.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path26.join(path26.dirname(Bun.main), "../../", pkgName, "package.json")
     ];
   }
   async#firstExisting(basePath2) {
@@ -11081,7 +11636,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path25.extname(filePath) === ".css";
+    return path26.extname(filePath) === ".css";
   }
 }
 
@@ -11148,7 +11703,7 @@ class CssCompiler {
     pageKeys
   } = {}) {
     pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path26.resolve(this.#app.cwdPath, "page", key));
+    const seeds = pageKeys.map((key) => path27.resolve(this.#app.cwdPath, "page", key));
     const cssFiles = new Set;
     const sourceFiles = new Set;
     const queue = [...seeds];
@@ -11180,7 +11735,7 @@ class CssCompiler {
       } catch {
         continue;
       }
-      const importerDir = path26.dirname(filePath);
+      const importerDir = path27.dirname(filePath);
       for (const imp of imports) {
         const spec = imp.path;
         if (!spec)
@@ -11206,7 +11761,7 @@ class CssCompiler {
     const compileStarted = Date.now();
     const compilers = await Promise.all(cssPaths.map(async (cssPath) => {
       const css = await Bun.file(cssPath).text();
-      const base = path26.dirname(cssPath);
+      const base = path27.dirname(cssPath);
       const compiler = await compile(css, {
         base,
         loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
@@ -11237,11 +11792,11 @@ class CssCompiler {
   async#loadStylesheet(id, fromBase) {
     const p = await this.#resolveCssImport(id, fromBase);
     const content = await Bun.file(p).text();
-    return { path: p, base: path26.dirname(p), content };
+    return { path: p, base: path27.dirname(p), content };
   }
   async#resolveCssImport(id, fromBase) {
     if (id.startsWith(".") || id.startsWith("/"))
-      return path26.resolve(fromBase, id);
+      return path27.resolve(fromBase, id);
     const resolver = await this.#getCssImportResolver();
     const resolved = await resolver.resolve(id, fromBase);
     if (resolved)
@@ -11257,11 +11812,11 @@ class CssCompiler {
   async#loadModule(id, fromBase) {
     const p = __require.resolve(id, { paths: [fromBase] });
     const mod = await import(p);
-    return { path: p, base: path26.dirname(p), module: mod.default ?? mod };
+    return { path: p, base: path27.dirname(p), module: mod.default ?? mod };
   }
   async#resolveSourceImport(id, fromBase, resolvePackage) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path26.resolve(fromBase, id);
+      const abs = id.startsWith("/") ? id : path27.resolve(fromBase, id);
       return resolveSourceFileCandidate(abs);
     }
     const pkg = await resolvePackage(id);
@@ -11303,7 +11858,7 @@ async function resolveSourceFileCandidate(absPathNoExt) {
       return filePath;
   }
   for (const ext of SOURCE_EXTS3) {
-    const filePath = path26.join(absPathNoExt, `index${ext}`);
+    const filePath = path27.join(absPathNoExt, `index${ext}`);
     if (await Bun.file(filePath).exists())
       return filePath;
   }
@@ -11326,19 +11881,19 @@ function resolveSourceWithRequire(id, fromBase) {
   }
 }
 function isSourceFile(filePath) {
-  return SOURCE_EXTS3.includes(path26.extname(filePath));
+  return SOURCE_EXTS3.includes(path27.extname(filePath));
 }
 function isIgnoredNodeModuleSource(filePath) {
   return NODE_MODULES_RE3.test(filePath) && !AKANJS_NODE_MODULE_RE3.test(filePath);
 }
 function getPageKeyBasePath(pageKey, basePaths) {
-  const normalized = pageKey.split(path26.sep).join("/").replace(/^\.\//, "");
+  const normalized = pageKey.split(path27.sep).join("/").replace(/^\.\//, "");
   const segments = normalized.split("/");
   const firstPublicSegment = segments.find((segment) => segment !== "[lang]" && !/^\(.+\)$/.test(segment));
   return firstPublicSegment && basePaths.includes(firstPublicSegment) ? firstPublicSegment : null;
 }
 // pkgs/@akanjs/devkit/frontendBuild/devChangePlanner.ts
-import path27 from "path";
+import path28 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", "plugin"]);
@@ -11350,11 +11905,11 @@ var RUNTIME_METADATA_BASENAMES2 = new Set(["dict.ts", "sig.ts", "useClient.ts",
 class DevChangePlanner {
   #workspaceRoot;
   constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path27.resolve(workspaceRoot);
+    this.#workspaceRoot = path28.resolve(workspaceRoot);
   }
   plan({ generation, files, kinds, generatedFiles: generatedFiles2 = [] }) {
     const fileList = uniqueResolved([...files, ...generatedFiles2]);
-    const generatedSet = new Set(generatedFiles2.map((file) => path27.resolve(file)));
+    const generatedSet = new Set(generatedFiles2.map((file) => path28.resolve(file)));
     const kindSet = new Set(kinds);
     const roles = new Set;
     const actions = new Set;
@@ -11371,13 +11926,13 @@ class DevChangePlanner {
     }
     for (const file of fileList) {
       const reasons = new Set;
-      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path27.resolve(file)), reasons });
+      const fileRoles = this.#rolesForFile(file, { isGenerated: generatedSet.has(path28.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[path27.resolve(file)] = [...reasons].sort();
+        reasonByFile[path28.resolve(file)] = [...reasons].sort();
     }
     if (roles.has("barrel"))
       actions.add("sync-generated");
@@ -11398,12 +11953,12 @@ class DevChangePlanner {
   }
   #rolesForFile(file, { isGenerated, reasons }) {
     const roles = new Set;
-    const abs = path27.resolve(file);
-    const base = path27.basename(abs);
-    const ext = path27.extname(abs).toLowerCase();
+    const abs = path28.resolve(file);
+    const base = path28.basename(abs);
+    const ext = path28.extname(abs).toLowerCase();
     const isSource = SOURCE_EXTS4.has(ext);
-    const rel = path27.relative(this.#workspaceRoot, abs);
-    const parts = rel.split(path27.sep).filter(Boolean);
+    const rel = path28.relative(this.#workspaceRoot, abs);
+    const parts = rel.split(path28.sep).filter(Boolean);
     if (CONFIG_BASENAMES.has(base)) {
       roles.add("config");
       reasons.add("config-file");
@@ -11444,15 +11999,15 @@ class DevChangePlanner {
     return roles;
   }
   #isServerBiased(abs, parts) {
-    const base = path27.basename(abs);
+    const base = path28.basename(abs);
     return parts.includes("srvkit") || SERVER_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || base === "main.ts" || base === "server.ts";
   }
   #isClientBiased(abs, parts) {
-    const base = path27.basename(abs);
+    const base = path28.basename(abs);
     return parts.includes("ui") || parts.includes("webkit") || parts.includes("page") || CLIENT_SUFFIXES.some((suffix) => base.endsWith(suffix));
   }
   #isSharedBiased(abs, parts) {
-    const base = path27.basename(abs);
+    const base = path28.basename(abs);
     return parts.includes("common") || SHARED_SUFFIXES2.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES2.has(base);
   }
   #isRuntimeMetadataFile(parts, base) {
@@ -11477,16 +12032,16 @@ class DevChangePlanner {
     return true;
   }
   #isWorkspaceSource(rel) {
-    if (!rel || rel.startsWith("..") || path27.isAbsolute(rel))
+    if (!rel || rel.startsWith("..") || path28.isAbsolute(rel))
       return false;
-    const [scope] = rel.split(path27.sep);
+    const [scope] = rel.split(path28.sep);
     return scope === "apps" || scope === "libs" || scope === "pkgs";
   }
 }
-var uniqueResolved = (files) => [...new Set(files.map((file) => path27.resolve(file)))].sort();
+var uniqueResolved = (files) => [...new Set(files.map((file) => path28.resolve(file)))].sort();
 // pkgs/@akanjs/devkit/frontendBuild/devGeneratedIndexSync.ts
-import { mkdir as mkdir6, readdir as readdir2, readFile, rm as rm3, stat as stat3, writeFile } from "fs/promises";
-import path28 from "path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile2, rm as rm3, stat as stat4, writeFile as writeFile2 } from "fs/promises";
+import path29 from "path";
 var BARREL_FACETS2 = new Set(["common", "srvkit", "ui", "webkit", "plugin"]);
 var FACET_SOURCE_FILE_RE = /\.(ts|tsx)$/;
 var FACET_EXCLUDED_FILE_RE = /(^index\.tsx?$|\.d\.ts$|\.(test|spec)\.(ts|tsx)$|\.css$|\.scss$|\.sass$)/;
@@ -11499,7 +12054,7 @@ var SCALAR_UI_TYPES = ["Template", "Unit"];
 class DevGeneratedIndexSync {
   #workspaceRoot;
   constructor({ workspaceRoot }) {
-    this.#workspaceRoot = path28.resolve(workspaceRoot);
+    this.#workspaceRoot = path29.resolve(workspaceRoot);
   }
   async syncForBatch(files) {
     const indexPaths = new Set;
@@ -11509,7 +12064,7 @@ class DevGeneratedIndexSync {
       if (facetIndex)
         indexPaths.add(facetIndex);
       const moduleIndex2 = await this.#moduleIndexForDirectoryEvent(file).catch((err) => {
-        errors.push(`[generated-index] module detection failed for ${file}: ${formatError(err)}`);
+        errors.push(`[generated-index] module detection failed for ${file}: ${formatError2(err)}`);
         return null;
       });
       if (moduleIndex2)
@@ -11522,17 +12077,17 @@ class DevGeneratedIndexSync {
         if (changed)
           changedFiles.push(indexPath);
       } catch (err) {
-        errors.push(`[generated-index] sync failed for ${indexPath}: ${formatError(err)}`);
+        errors.push(`[generated-index] sync failed for ${indexPath}: ${formatError2(err)}`);
       }
     }
     return { changedFiles, errors };
   }
   #facetIndexFor(file) {
-    const abs = path28.resolve(file);
-    const rel = path28.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path28.isAbsolute(rel))
+    const abs = path29.resolve(file);
+    const rel = path29.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path29.isAbsolute(rel))
       return null;
-    const parts = rel.split(path28.sep).filter(Boolean);
+    const parts = rel.split(path29.sep).filter(Boolean);
     if (parts.length < 4)
       return null;
     const [scope, project, facet, child] = parts;
@@ -11540,32 +12095,32 @@ class DevGeneratedIndexSync {
       return null;
     if (!child || child.startsWith(".") || child === "index.ts" || child === "index.tsx")
       return null;
-    return path28.join(this.#workspaceRoot, scope, project, facet, "index.ts");
+    return path29.join(this.#workspaceRoot, scope, project, facet, "index.ts");
   }
   async#moduleIndexForDirectoryEvent(file) {
-    const abs = path28.resolve(file);
-    const rel = path28.relative(this.#workspaceRoot, abs);
-    if (rel.startsWith("..") || path28.isAbsolute(rel))
+    const abs = path29.resolve(file);
+    const rel = path29.relative(this.#workspaceRoot, abs);
+    if (rel.startsWith("..") || path29.isAbsolute(rel))
       return null;
-    const parts = rel.split(path28.sep).filter(Boolean);
+    const parts = rel.split(path29.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 = !path28.extname(abs);
+    const isExistingDirectory = await stat4(abs).then((s) => s.isDirectory()).catch(() => false);
+    const looksLikeDeletedDirectory = !path29.extname(abs);
     if (!isExistingDirectory && !looksLikeDeletedDirectory)
       return null;
     if (moduleSegment === "__scalar" && scalarSegment) {
-      return path28.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
+      return path29.join(this.#workspaceRoot, scope, project, "lib", "__scalar", scalarSegment, "index.ts");
     }
     if (!moduleSegment || moduleSegment === "__scalar")
       return null;
-    return path28.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
+    return path29.join(this.#workspaceRoot, scope, project, "lib", moduleSegment, "index.ts");
   }
   async#syncIndex(indexPath) {
-    const dir = path28.dirname(indexPath);
+    const dir = path29.dirname(indexPath);
     const content = await this.#contentForIndex(indexPath);
     if (content === null) {
       if (!await exists(indexPath))
@@ -11573,23 +12128,23 @@ class DevGeneratedIndexSync {
       await rm3(indexPath, { force: true });
       return true;
     }
-    const current = await readFile(indexPath, "utf8").catch(() => null);
+    const current = await readFile2(indexPath, "utf8").catch(() => null);
     if (current === content)
       return false;
     await mkdir6(dir, { recursive: true });
-    await writeFile(indexPath, content);
+    await writeFile2(indexPath, content);
     return true;
   }
   async#contentForIndex(indexPath) {
-    const parts = path28.relative(this.#workspaceRoot, indexPath).split(path28.sep).filter(Boolean);
+    const parts = path29.relative(this.#workspaceRoot, indexPath).split(path29.sep).filter(Boolean);
     const facet = parts.at(-2);
     if (facet && BARREL_FACETS2.has(facet))
-      return this.#facetContent(path28.dirname(indexPath));
-    return this.#moduleContent(path28.dirname(indexPath));
+      return this.#facetContent(path29.dirname(indexPath));
+    return this.#moduleContent(path29.dirname(indexPath));
   }
   async#facetContent(dir) {
-    const nameCasePattern = path28.basename(dir) === "ui" ? FACET_PASCAL_CASE_RE : FACET_CAMEL_CASE_RE;
-    const entries = await readdir2(dir, { withFileTypes: true }).catch(() => []);
+    const nameCasePattern = path29.basename(dir) === "ui" ? FACET_PASCAL_CASE_RE : FACET_CAMEL_CASE_RE;
+    const entries = await readdir3(dir, { withFileTypes: true }).catch(() => []);
     const exportNames = entries.flatMap((entry) => {
       const name = entry.name;
       if (name.startsWith("."))
@@ -11610,8 +12165,8 @@ class DevGeneratedIndexSync {
 `;
   }
   async#moduleContent(dir) {
-    const rel = path28.relative(this.#workspaceRoot, dir);
-    const parts = rel.split(path28.sep).filter(Boolean);
+    const rel = path29.relative(this.#workspaceRoot, dir);
+    const parts = rel.split(path29.sep).filter(Boolean);
     const moduleSegment = parts.at(-1);
     if (!moduleSegment)
       return null;
@@ -11623,7 +12178,7 @@ class DevGeneratedIndexSync {
     const allowedTypes = isScalar ? SCALAR_UI_TYPES : moduleSegment.startsWith("_") ? SERVICE_UI_TYPES : MODULE_UI_TYPES;
     const fileTypes = [];
     for (const type of allowedTypes) {
-      if (await exists(path28.join(dir, `${modelName}.${type}.tsx`)))
+      if (await exists(path29.join(dir, `${modelName}.${type}.tsx`)))
         fileTypes.push(type);
     }
     if (fileTypes.length === 0)
@@ -11635,12 +12190,12 @@ ${fileTypes.map((type) => `import * as ${type} from "./${modelName}.${type}";`).
 export const ${modelName} = { ${fileTypes.join(", ")} };`;
   }
 }
-var exists = async (file) => stat3(file).then(() => true).catch(() => false);
+var exists = async (file) => stat4(file).then(() => true).catch(() => false);
 var capitalize4 = (value) => `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
-var formatError = (err) => err instanceof Error ? err.message : String(err);
+var formatError2 = (err) => err instanceof Error ? err.message : String(err);
 // pkgs/@akanjs/devkit/frontendBuild/fontOptimizer.ts
 import { mkdir as mkdir7 } from "fs/promises";
-import path29 from "path";
+import path30 from "path";
 import {
   generateFontFace,
   getMetricsForFamily,
@@ -11649,7 +12204,7 @@ import {
 } from "fontaine";
 import { createFont, woff2 } from "fonteditor-core";
 import subsetFont from "subset-font";
-import ts9 from "typescript";
+import ts10 from "typescript";
 var FONT_URL_PREFIX = "/_akan/fonts";
 var DEFAULT_FONT_SUBSETS = ["latin"];
 
@@ -11664,7 +12219,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path29.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path30.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -11683,7 +12238,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path29.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path30.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -11699,8 +12254,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path29.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir7(path29.dirname(outputPath), { recursive: true });
+      const outputPath = path30.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir7(path30.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);
@@ -11714,17 +12269,17 @@ class FontOptimizer {
       this.#cssParts.push(...faceCss, this.#buildRootVariableRule(font));
   }
   #extractFontsExport(source2, filePath) {
-    const sourceFile2 = ts9.createSourceFile(filePath, source2, ts9.ScriptTarget.Latest, true, ts9.ScriptKind.TSX);
+    const sourceFile2 = ts10.createSourceFile(filePath, source2, ts10.ScriptTarget.Latest, true, ts10.ScriptKind.TSX);
     const fonts = [];
     for (const statement of sourceFile2.statements) {
-      if (!ts9.isVariableStatement(statement))
+      if (!ts10.isVariableStatement(statement))
         continue;
-      const modifiers = ts9.canHaveModifiers(statement) ? ts9.getModifiers(statement) : undefined;
-      const isExported = modifiers?.some((modifier) => modifier.kind === ts9.SyntaxKind.ExportKeyword) ?? false;
+      const modifiers = ts10.canHaveModifiers(statement) ? ts10.getModifiers(statement) : undefined;
+      const isExported = modifiers?.some((modifier) => modifier.kind === ts10.SyntaxKind.ExportKeyword) ?? false;
       if (!isExported)
         continue;
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts9.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
+        if (!ts10.isIdentifier(declaration.name) || declaration.name.text !== "fonts")
           continue;
         const value = declaration.initializer ? this.#literalToValue(declaration.initializer) : null;
         if (Array.isArray(value)) {
@@ -11735,20 +12290,20 @@ class FontOptimizer {
     return fonts;
   }
   #literalToValue(node) {
-    if (ts9.isStringLiteralLike(node))
+    if (ts10.isStringLiteralLike(node))
       return node.text;
-    if (ts9.isNumericLiteral(node))
+    if (ts10.isNumericLiteral(node))
       return Number(node.text);
-    if (node.kind === ts9.SyntaxKind.TrueKeyword)
+    if (node.kind === ts10.SyntaxKind.TrueKeyword)
       return true;
-    if (node.kind === ts9.SyntaxKind.FalseKeyword)
+    if (node.kind === ts10.SyntaxKind.FalseKeyword)
       return false;
-    if (ts9.isArrayLiteralExpression(node))
+    if (ts10.isArrayLiteralExpression(node))
       return node.elements.map((element) => this.#literalToValue(element));
-    if (ts9.isObjectLiteralExpression(node)) {
+    if (ts10.isObjectLiteralExpression(node)) {
       const obj = {};
       for (const prop of node.properties) {
-        if (!ts9.isPropertyAssignment(prop))
+        if (!ts10.isPropertyAssignment(prop))
           continue;
         const name = this.#getPropertyName(prop.name);
         if (!name)
@@ -11757,13 +12312,13 @@ class FontOptimizer {
       }
       return obj;
     }
-    if (ts9.isAsExpression(node) || ts9.isSatisfiesExpression(node) || ts9.isParenthesizedExpression(node)) {
+    if (ts10.isAsExpression(node) || ts10.isSatisfiesExpression(node) || ts10.isParenthesizedExpression(node)) {
       return this.#literalToValue(node.expression);
     }
     return;
   }
   #getPropertyName(name) {
-    if (ts9.isIdentifier(name) || ts9.isStringLiteral(name) || ts9.isNumericLiteral(name))
+    if (ts10.isIdentifier(name) || ts10.isStringLiteral(name) || ts10.isNumericLiteral(name))
       return name.text;
     return null;
   }
@@ -11847,8 +12402,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path29.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path29.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path30.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path30.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -11876,7 +12431,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path29.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path30.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -11885,7 +12440,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path29.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path30.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -11895,7 +12450,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path29.isAbsolute(filePath) ? filePath : path29.join(this.#app.cwdPath, filePath);
+      const abs = path30.isAbsolute(filePath) ? filePath : path30.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -11914,7 +12469,7 @@ class FontOptimizer {
     return "";
   }
   async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path29.join(this.#app.cwdPath, dir));
+    const roots = ["page", "ui"].map((dir) => path30.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) => {
@@ -12028,7 +12583,7 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path30 from "path";
+import path31 from "path";
 var SOURCE_EXTS5 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CSS_EXTS = new Set([".css"]);
 var CONFIG_BASENAMES2 = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
@@ -12037,10 +12592,10 @@ class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path30.basename(abs);
+    const base = path31.basename(abs);
     if (CONFIG_BASENAMES2.has(base))
       return "config";
-    const ext = path30.extname(abs).toLowerCase();
+    const ext = path31.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
     if (SOURCE_EXTS5.has(ext))
@@ -12048,23 +12603,23 @@ class HmrChangeClassifier {
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path30.basename(abs);
+    const base = path31.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(`${path30.sep}node_modules${path30.sep}`))
+    if (abs.includes(`${path31.sep}node_modules${path31.sep}`))
       return true;
-    if (abs.includes(`${path30.sep}.akan${path30.sep}`))
+    if (abs.includes(`${path31.sep}.akan${path31.sep}`))
       return true;
     return false;
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs4 from "fs";
-import path31 from "path";
+import path32 from "path";
 class HmrWatcher {
   #roots;
   #debounceMs;
@@ -12077,7 +12632,7 @@ class HmrWatcher {
   #stopped = false;
   #flushing = false;
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path31.resolve(r)))];
+    this.#roots = [...new Set(opts.roots.map((r) => path32.resolve(r)))];
     this.#debounceMs = opts.debounceMs ?? 80;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -12088,7 +12643,7 @@ class HmrWatcher {
         const w = fs4.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path31.resolve(root, filename.toString());
+          const abs = path32.resolve(root, filename.toString());
           this.#queue(abs);
         });
         this.#watchers.push(w);
@@ -12146,10 +12701,10 @@ class HmrWatcher {
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path33 from "path";
+import path34 from "path";
 
 // pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path32 from "path";
+import path33 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/"];
@@ -12192,7 +12747,7 @@ async function createExternalizeFrameworkPlugin(options) {
         const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
         if (!replPath)
           continue;
-        const candidate = path32.resolve(workspaceRoot, replPath + suffix);
+        const candidate = path33.resolve(workspaceRoot, replPath + suffix);
         const hit = await firstExisting(candidate);
         if (hit)
           return hit;
@@ -12204,8 +12759,8 @@ async function createExternalizeFrameworkPlugin(options) {
       if (spec === pkg)
         continue;
       const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path32.dirname(path32.resolve(workspaceRoot, entryFile));
-      const candidate = path32.join(pkgDir, suffix);
+      const pkgDir = path33.dirname(path33.resolve(workspaceRoot, entryFile));
+      const candidate = path33.join(pkgDir, suffix);
       const hit = await firstExisting(candidate);
       if (hit)
         return hit;
@@ -12255,7 +12810,7 @@ async function firstExisting(basePath2) {
       return candidate;
   }
   for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path32.join(basePath2, `index${ext}`);
+    const candidate = path33.join(basePath2, `index${ext}`);
     if (await Bun.file(candidate).exists())
       return candidate;
   }
@@ -12346,11 +12901,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 = path33.resolve(entryArtifact.path);
+    const bundlePath = path34.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] ${path33.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] ${path34.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,
@@ -12432,11 +12987,11 @@ function loaderFor4(absPath) {
 }
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
 import fs5 from "fs";
-import path34 from "path";
+import path35 from "path";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
 async function precompressArtifacts(app) {
-  const roots = [path34.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const roots = [path35.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) {
@@ -12462,7 +13017,7 @@ async function precompressRoot(root, result) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path34.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path35.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -12480,7 +13035,7 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path35 from "path";
+import path36 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath2, cssText) {
   return optimize(cssText, { file: `${basePath2 || "root"}.css`, minify: command === "build" }).code;
@@ -12496,7 +13051,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path35.resolve(this.#artifactDir);
+    this.#absArtifactDir = path36.resolve(this.#artifactDir);
   }
   async build() {
     const akanConfig2 = await this.#app.getConfig();
@@ -12518,7 +13073,7 @@ class SsrBaseArtifactBuilder {
       rscRuntimeSsrManifest,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path35.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path36.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]])),
@@ -12534,18 +13089,18 @@ class SsrBaseArtifactBuilder {
         androidSha256CertFingerprints: target.deepLinks?.android?.sha256CertFingerprints
       }))
     };
-    await Bun.write(path35.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path36.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 };
   }
   async#buildRuntimeClientEntries() {
     const akanServerPath = await this.#resolveAkanServerPath();
-    const rscClientEntry = path35.resolve(akanServerPath, "rscClient.tsx");
-    const rscSegmentOutletEntry = path35.resolve(akanServerPath, "rscSegmentOutlet.tsx");
+    const rscClientEntry = path36.resolve(akanServerPath, "rscClient.tsx");
+    const rscSegmentOutletEntry = path36.resolve(akanServerPath, "rscSegmentOutlet.tsx");
     const vendorEntries = VENDOR_SPECIFIERS.map((specifier) => ({
       specifier,
-      absPath: path35.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
+      absPath: path36.resolve(akanServerPath, "vendor", `${specifier.replaceAll("/", "-").replaceAll(".", "-")}.ts`)
     }));
     const entries = [rscClientEntry, rscSegmentOutletEntry, ...vendorEntries.map((v) => v.absPath)];
     const clientBundle = await new ClientEntriesBundler({ app: this.#app, entries, command: this.#command }).bundle();
@@ -12582,15 +13137,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path35.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path36.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path35.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path35.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path36.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path36.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path35.dirname(Bun.resolveSync("akanjs/server", path35.dirname(Bun.main))));
+      candidates.push(path36.dirname(Bun.resolveSync("akanjs/server", path36.dirname(Bun.main))));
     } catch {}
-    candidates.push(path35.join(path35.dirname(Bun.main), "node_modules/akanjs/server"), path35.join(path35.dirname(Bun.main), "../../akanjs/server"), path35.resolve(import.meta.dir, "../../server"), path35.resolve(import.meta.dir, "../server"));
+    candidates.push(path36.join(path36.dirname(Bun.main), "node_modules/akanjs/server"), path36.join(path36.dirname(Bun.main), "../../akanjs/server"), path36.resolve(import.meta.dir, "../../server"), path36.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path35.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path36.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -12619,14 +13174,14 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path35.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path36.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 path36 from "path";
+import path37 from "path";
 
 class WatchRootResolver {
   #app;
@@ -12636,15 +13191,15 @@ class WatchRootResolver {
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
     const set = new Set;
-    set.add(path36.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path37.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path36.isAbsolute(target))
+        if (path37.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path36.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path37.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (fs6.existsSync(resolved))
           set.add(resolved);
       }
@@ -12711,7 +13266,7 @@ class ApplicationBuildRunner {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path37.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path38.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
@@ -12719,7 +13274,7 @@ class ApplicationBuildRunner {
     await this.#app.getPageKeys({ refresh: true });
     const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
     if (clean)
-      await rm4(path37.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm4(path38.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
   async#runPhase(id, label, task, summarize, options = {}) {
@@ -12791,7 +13346,7 @@ class ApplicationBuildRunner {
     };
   }
   async#writeConsoleShim() {
-    await Bun.write(path37.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+    await Bun.write(path38.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 () => {
@@ -12814,14 +13369,14 @@ void run().catch((error) => {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path37.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path38.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
     }
   }
   #resolveConsoleRuntimeBuildEntry() {
     try {
-      return path37.join(path37.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+      return path38.join(path38.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
     } catch {
-      return path37.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+      return path38.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
   async#buildCsr() {
@@ -12838,7 +13393,7 @@ void run().catch((error) => {
     return { base, allRoutes };
   }
   async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path37.join(this.#app.cwdPath, ".akan", "typecheck");
+    const typecheckDir = path38.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir8(typecheckDir, { recursive: true });
     const tsconfig = {
       extends: "../../tsconfig.json",
@@ -12857,7 +13412,7 @@ void run().catch((error) => {
       ],
       references: []
     };
-    const tsconfigPath = path37.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path38.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -12883,10 +13438,10 @@ void run().catch((error) => {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path37.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path37.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path37.join(import.meta.dir, "typecheck.proc.js"),
-      path37.join(import.meta.dir, "typecheck.proc.ts")
+      path38.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path38.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path38.join(import.meta.dir, "typecheck.proc.js"),
+      path38.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -12920,7 +13475,7 @@ void run().catch((error) => {
 }
 // pkgs/@akanjs/devkit/applicationReleasePackager.ts
 import { cp, mkdir as mkdir9, rm as rm5 } from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 
 // pkgs/@akanjs/devkit/uploadRelease.ts
 import { HttpClient as HttpClient2, Logger as Logger9 } from "akanjs/common";
@@ -13037,7 +13592,7 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
     await rm5(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
     const releaseRoot = this.#app.workspace.workspaceRoot;
-    const releaseArchivePath = path38.relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`).split(path38.sep).join("/");
+    const releaseArchivePath = path39.relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`).split(path39.sep).join("/");
     await this.#app.workspace.spawn("tar", ["-zcf", releaseArchivePath, "-C", buildRoot, "./"], { cwd: releaseRoot });
     await this.#writeCsrZipIfPresent();
     return { platformVersion };
@@ -13059,17 +13614,17 @@ 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 (path39) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path39}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path40) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path40}`;
       if (await FileSys.dirExists(targetPath))
         await rm5(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path39) => cp(`${this.#app.workspace.cwdPath}/${path39}`, `${sourceRoot}/${path39}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path40) => cp(`${this.#app.workspace.cwdPath}/${path40}`, `${sourceRoot}/${path40}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     const sourceCwd = this.#app.workspace.cwdPath;
-    const sourceArchivePath = path38.relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`).split(path38.sep).join("/");
+    const sourceArchivePath = path39.relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`).split(path39.sep).join("/");
     await this.#app.workspace.spawn("tar", ["-zcf", sourceArchivePath, "-C", sourceRoot, "./"], { cwd: sourceCwd });
   }
   async#resetSourceRoot(sourceRoot) {
@@ -13152,20 +13707,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path39 from "path";
+import path40 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path39.join(path39.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path40.join(path40.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path39.dirname(Bun.main));
+  addResolvedPackageCandidate(path40.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path39.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.join(path39.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path39.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path40.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path40.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path40.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path40.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path40.join(path40.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path40.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   const uniqueCandidates = [...new Set(candidates)];
   for (const candidate of uniqueCandidates) {
     if (await Bun.file(candidate).exists())
@@ -13179,7 +13734,7 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
-import path40 from "path";
+import path41 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"]));
@@ -13196,14 +13751,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(path40.sep);
+      const segments = relativePath.split(path41.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path40.join(cwd, rel));
+    }).map((rel) => path41.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(path40.sep);
+      const segments = relativePath.split(path41.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -13211,17 +13766,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path40.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path41.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path40.isAbsolute(p) ? p : path40.join(cwd, p));
+        out.push(path41.isAbsolute(p) ? p : path41.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path40.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path41.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -13242,9 +13797,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path40.join(cwd, relativePath);
-      const targetPath = path40.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir10(path40.dirname(targetPath), { recursive: true });
+      const sourcePath = path41.join(cwd, relativePath);
+      const targetPath = path41.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir10(path41.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -13255,13 +13810,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path40.posix.parse(withoutFormatDir);
+    const parsed = path41.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path40.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path41.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(path40.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path41.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -13310,9 +13865,9 @@ class Builder {
   }
 }
 // pkgs/@akanjs/devkit/capacitorApp.ts
-import { cp as cp2, mkdir as mkdir11, readFile as readFile2, rm as rm6, writeFile as writeFile2 } from "fs/promises";
+import { cp as cp2, mkdir as mkdir11, readFile as readFile3, rm as rm6, writeFile as writeFile3 } from "fs/promises";
 import os from "os";
-import path41 from "path";
+import path42 from "path";
 import { select as select2 } from "@inquirer/prompts";
 import { MobileProject } from "@trapezedev/project";
 import { capitalize as capitalize5 } from "akanjs/common";
@@ -13519,13 +14074,13 @@ var rootCapacitorConfigFilenames = [
   "capacitor.config.js",
   "capacitor.config.json"
 ];
-var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path41.join(appRoot, file));
+var rootCapacitorConfigPaths = (appRoot) => rootCapacitorConfigFilenames.map((file) => path42.join(appRoot, file));
 async function clearRootCapacitorConfigs(appRoot) {
   await Promise.all(rootCapacitorConfigPaths(appRoot).map((file) => rm6(file, { force: true })));
 }
 async function writeRootCapacitorConfig(appRoot, content) {
   await clearRootCapacitorConfigs(appRoot);
-  await Bun.write(path41.join(appRoot, "capacitor.config.json"), content);
+  await Bun.write(path42.join(appRoot, "capacitor.config.json"), content);
 }
 var getLocalIP = () => {
   const interfaces = os.networkInterfaces();
@@ -13634,13 +14189,13 @@ function buildIosNativeRunCommand({
   scheme = "App",
   configuration = "Debug"
 }) {
-  const derivedDataPath = path41.join(appRoot, "ios/DerivedData", device.id);
+  const derivedDataPath = path42.join(appRoot, "ios/DerivedData", device.id);
   const productPlatform = device.kind === "device" ? "iphoneos" : "iphonesimulator";
   const destination = device.kind === "device" ? `id=${device.xcodebuildId ?? device.id}` : `platform=iOS Simulator,id=${device.id}`;
   return {
     configuration,
     derivedDataPath,
-    appPath: path41.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
+    appPath: path42.join(derivedDataPath, "Build/Products", `${configuration}-${productPlatform}`, "App.app"),
     xcodebuildArgs: [
       "-project",
       "App.xcodeproj",
@@ -13853,7 +14408,7 @@ function materializeCapacitorConfig(target, { operation, localServerUrl, localIp
     ...capacitorConfig,
     appId,
     appName,
-    webDir: path41.posix.join(".akan", "mobile", name, "www"),
+    webDir: path42.posix.join(".akan", "mobile", name, "www"),
     plugins: {
       CapacitorCookies: { enabled: true },
       ...pluginsConfig,
@@ -13917,10 +14472,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path41.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path41.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path41.join(this.targetRoot, "www");
-    this.targetAssetRoot = path41.join(this.targetRoot, "assets");
+    this.targetRootPath = path42.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path42.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path42.join(this.targetRoot, "www");
+    this.targetAssetRoot = path42.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -13935,9 +14490,9 @@ class CapacitorApp {
     await mkdir11(this.targetRoot, { recursive: true });
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm6(path41.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm6(path42.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm6(path41.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm6(path42.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -14061,7 +14616,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     const xcodebuildArgs = noAllowProvisioningUpdates ? command.xcodebuildArgs : [...command.xcodebuildArgs.slice(0, -1), "-allowProvisioningUpdates", ...command.xcodebuildArgs.slice(-1)];
     try {
       await this.#spawn("xcodebuild", xcodebuildArgs, {
-        cwd: path41.join(this.app.cwdPath, this.iosProjectPath),
+        cwd: path42.join(this.app.cwdPath, this.iosProjectPath),
         env: mobileEnv
       });
       const devicectlId = runTarget.devicectlId ?? runTarget.id;
@@ -14086,7 +14641,7 @@ ${textError instanceof Error ? textError.message : ""}`);
     return isRecord2(this.target.ios) && typeof this.target.ios.scheme === "string" ? this.target.ios.scheme : "App";
   }
   async#getIosDevelopmentTeam() {
-    const pbxprojPath = path41.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const pbxprojPath = path42.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
     if (!await Bun.file(pbxprojPath).exists())
       return;
     return (await Bun.file(pbxprojPath).text()).match(/DEVELOPMENT_TEAM = ([^;]+);/)?.[1]?.trim();
@@ -14113,7 +14668,7 @@ ${error.message}`;
     await this.#setDeepLinksInAndroid(this.target.deepLinks?.schemes ?? [], this.target.deepLinks?.domains ?? []);
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path41.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path42.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -14157,7 +14712,7 @@ ${error.message}`;
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path41.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path42.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -14165,10 +14720,10 @@ ${error.message}`;
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir11(path41.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir11(path42.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path41.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path42.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -14207,7 +14762,7 @@ ${error.message}`;
     await this.#spawnMobile("npx", args, { operation, env }, { stdio: "inherit" });
   }
   async#assertAndroidReleaseSigningConfig() {
-    const gradlePropertiesPath = path41.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
+    const gradlePropertiesPath = path42.join(this.app.cwdPath, this.androidRootPath, "gradle.properties");
     const gradleProperties = await Bun.file(gradlePropertiesPath).exists() ? await Bun.file(gradlePropertiesPath).text() : "";
     const missingKeys = getMissingAndroidReleaseSigningKeys({ gradleProperties });
     if (missingKeys.length > 0)
@@ -14234,12 +14789,12 @@ ${error.message}`;
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path41.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path42.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 rm6(this.targetWebRoot, { recursive: true, force: true });
     await mkdir11(this.targetWebRoot, { recursive: true });
-    await Bun.write(path41.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await Bun.write(path42.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -14263,7 +14818,7 @@ ${error.message}`;
     });
     const content = `${JSON.stringify(config, null, 2)}
 `;
-    await Bun.write(path41.join(this.targetRoot, "capacitor.config.json"), content);
+    await Bun.write(path42.join(this.targetRoot, "capacitor.config.json"), content);
     return content;
   }
   async#prepareTargetAssets() {
@@ -14271,11 +14826,11 @@ ${error.message}`;
       return;
     await mkdir11(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path41.join(this.app.cwdPath, this.target.assets.icon), path41.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path42.join(this.app.cwdPath, this.target.assets.icon), path42.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path41.join(this.app.cwdPath, this.target.assets.splash), path41.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path42.join(this.app.cwdPath, this.target.assets.splash), path42.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -14283,11 +14838,11 @@ ${error.message}`;
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path41.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path42.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path41.join(platformRoot, to);
-      await mkdir11(path41.dirname(targetPath), { recursive: true });
-      await cp2(path41.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path42.join(platformRoot, to);
+      await mkdir11(path42.dirname(targetPath), { recursive: true });
+      await cp2(path42.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -14297,7 +14852,7 @@ ${error.message}`;
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path41.posix.join(this.targetRootPath, "assets"),
+      path42.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -14331,13 +14886,18 @@ ${error.message}`;
     }
     for (const permission of this.target.permissions ?? []) {
       const claimants = nativePlugins.get(permission);
-      if (!claimants?.length) {
-        this.app.logger.warn(`Mobile target '${this.target.name}' declares permission '${permission}' but no plugin configures it. ` + `Depend on a lib (e.g. @libs/util) whose akan.config declares a plugin with capacitor.permission '${permission}'.`);
+      if (claimants?.length) {
+        const ctx = this.#makeNativeContext({ operation, env });
+        for (const plugin of claimants)
+          await plugin.capacitor?.configureNative?.(ctx);
         continue;
       }
-      const ctx = this.#makeNativeContext({ operation, env });
-      for (const plugin of claimants)
-        await plugin.capacitor?.configureNative?.(ctx);
+      if (permission === "camera")
+        await this.addCamera();
+      else if (permission === "contacts")
+        await this.addContact();
+      else if (permission === "location")
+        await this.addLocation();
     }
   }
   #makeNativeContext({ operation, env }) {
@@ -14454,11 +15014,33 @@ ${error.message}`;
       await this.#clearRootCapacitorConfigs();
     }
   }
+  async addCamera() {
+    await this.#setPermissionInIos({
+      cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+      photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+      photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+    });
+    this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
+  }
+  async addContact() {
+    await this.#setPermissionInIos({
+      contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts."
+    });
+    this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
+  }
+  async addLocation() {
+    await this.#setPermissionInIos({
+      locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+      locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+    });
+    this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
+    this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
+  }
   #addIosEntitlements(entitlements) {
     Object.assign(this.#iosEntitlements, entitlements);
   }
   async#editIosAppDelegate(transform) {
-    const appDelegatePath = path41.join(this.app.cwdPath, this.iosProjectPath, "App/AppDelegate.swift");
+    const appDelegatePath = path42.join(this.app.cwdPath, this.iosProjectPath, "App/AppDelegate.swift");
     if (!await Bun.file(appDelegatePath).exists())
       return;
     const editor = await FileEditor.create(appDelegatePath);
@@ -14500,7 +15082,7 @@ ${error.message}`;
     if (Object.keys(this.#iosEntitlements).length === 0)
       return;
     const entitlementsRelPath = "App/App.entitlements";
-    const entitlementsPath = path41.join(this.app.cwdPath, this.iosProjectPath, entitlementsRelPath);
+    const entitlementsPath = path42.join(this.app.cwdPath, this.iosProjectPath, entitlementsRelPath);
     const body = [
       '<?xml version="1.0" encoding="UTF-8"?>',
       '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
@@ -14514,12 +15096,12 @@ ${error.message}`;
 `);
     const currentBody = await Bun.file(entitlementsPath).exists() ? await Bun.file(entitlementsPath).text() : undefined;
     if (currentBody !== body)
-      await writeFile2(entitlementsPath, body);
+      await writeFile3(entitlementsPath, body);
     await this.#setCodeSignEntitlementsInIos(entitlementsRelPath);
   }
   async#setCodeSignEntitlementsInIos(entitlementsRelPath) {
-    const pbxprojPath = path41.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
-    const lines = (await readFile2(pbxprojPath, "utf8")).split(`
+    const pbxprojPath = path42.join(this.app.cwdPath, this.iosProjectPath, "App.xcodeproj/project.pbxproj");
+    const lines = (await readFile3(pbxprojPath, "utf8")).split(`
 `);
     let changed = false;
     for (let index = 0;index < lines.length; index++) {
@@ -14541,12 +15123,12 @@ ${error.message}`;
       changed = true;
     }
     if (changed)
-      await writeFile2(pbxprojPath, lines.join(`
+      await writeFile3(pbxprojPath, lines.join(`
 `));
   }
   async#setUrlSchemesInAndroid(schemes) {
-    const manifestPath = path41.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
-    let manifest = await readFile2(manifestPath, "utf8");
+    const manifestPath = path42.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile3(manifestPath, "utf8");
     let changed = false;
     for (const scheme of schemes) {
       if (manifest.includes(`android:scheme="${scheme}"`))
@@ -14565,12 +15147,12 @@ ${filter}$1`);
       changed = true;
     }
     if (changed)
-      await writeFile2(manifestPath, manifest);
+      await writeFile3(manifestPath, manifest);
   }
   async#setDeepLinksInAndroid(schemes, domains) {
     await this.#setUrlSchemesInAndroid(schemes);
-    const manifestPath = path41.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
-    let manifest = await readFile2(manifestPath, "utf8");
+    const manifestPath = path42.join(this.app.cwdPath, this.androidRootPath, "app/src/main/AndroidManifest.xml");
+    let manifest = await readFile3(manifestPath, "utf8");
     let changed = false;
     const pathPrefix = resolveMobilePath(this.target, "/");
     for (const domain of domains) {
@@ -14590,7 +15172,7 @@ ${filter}$1`);
       changed = true;
     }
     if (changed)
-      await writeFile2(manifestPath, manifest);
+      await writeFile3(manifestPath, manifest);
   }
   #setFeaturesInAndroid(features) {
     for (const feature of features) {
@@ -14671,7 +15253,7 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path42 from "path";
+import path43 from "path";
 import { confirm, input as input2, select as select3 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
@@ -15175,7 +15757,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path42.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path43.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -15422,7 +16004,7 @@ import { capitalize as capitalize7 } from "akanjs/common";
 // pkgs/@akanjs/devkit/getRelatedCnsts.ts
 import { readFileSync as readFileSync4, realpathSync } from "fs";
 import ora2 from "ora";
-import * as ts10 from "typescript";
+import * as ts11 from "typescript";
 var tsTranspiler = new Bun.Transpiler({ loader: "ts" });
 var tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
 var getTranspiler = (filePath) => filePath.endsWith(".tsx") ? tsxTranspiler : tsTranspiler;
@@ -15455,10 +16037,10 @@ var scanModuleSpecifiers = (source2, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts10.readConfigFile(tsConfigPath, (path43) => {
-    return ts10.sys.readFile(path43);
+  const configFile = ts11.readConfigFile(tsConfigPath, (path44) => {
+    return ts11.sys.readFile(path44);
   });
-  return ts10.parseJsonConfigFileContent(configFile.config, ts10.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
+  return ts11.parseJsonConfigFileContent(configFile.config, ts11.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
 var collectImportedFiles = (constantFilePath, parsedConfig) => {
   const allFilesToAnalyze = new Set([constantFilePath]);
@@ -15473,7 +16055,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
     for (const importPath of scanModuleSpecifiers(source2, filePath, false)) {
       if (!importPath.startsWith("."))
         continue;
-      const resolved = ts10.resolveModuleName(importPath, filePath, parsedConfig.options, ts10.sys).resolvedModule?.resolvedFileName;
+      const resolved = ts11.resolveModuleName(importPath, filePath, parsedConfig.options, ts11.sys).resolvedModule?.resolvedFileName;
       if (resolved && !allFilesToAnalyze.has(resolved)) {
         allFilesToAnalyze.add(resolved);
         collectImported(resolved);
@@ -15490,7 +16072,7 @@ var collectImportedFiles = (constantFilePath, parsedConfig) => {
 var createTsProgram = (filePaths, options) => {
   const spinner = ora2("Creating TypeScript program for all files...");
   spinner.start();
-  const program2 = ts10.createProgram(Array.from(filePaths), options);
+  const program2 = ts11.createProgram(Array.from(filePaths), options);
   const checker = program2.getTypeChecker();
   spinner.succeed("TypeScript program created.");
   return {
@@ -15530,17 +16112,17 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
     function visit(node) {
       if (!source2)
         return;
-      if (ts10.isPropertyAccessExpression(node)) {
+      if (ts11.isPropertyAccessExpression(node)) {
         const left = node.expression;
         const right = node.name;
-        const { line } = ts10.getLineAndCharacterOfPosition(source2, node.getStart());
-        if (ts10.isIdentifier(left) && sourceLines && sourceLines.length > line && sourceLines[line] && (sourceLines[line]?.includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
+        const { line } = ts11.getLineAndCharacterOfPosition(source2, node.getStart());
+        if (ts11.isIdentifier(left) && sourceLines && sourceLines.length > line && sourceLines[line] && (sourceLines[line]?.includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
           const symbol = getCachedSymbol(right);
           if (symbol?.declarations && symbol.declarations.length > 0) {
             const key = symbol.declarations[0]?.getSourceFile().fileName.split("/").pop()?.split(".")[0] ?? "";
             const property = propertyMap.get(key);
             const isScalar = symbol.declarations[0]?.getSourceFile().fileName.includes("_") ?? false;
-            const symbolFilePath = symbol.declarations[0]?.getSourceFile().fileName.replace(`${ts10.sys.getCurrentDirectory()}/`, "");
+            const symbolFilePath = symbol.declarations[0]?.getSourceFile().fileName.replace(`${ts11.sys.getCurrentDirectory()}/`, "");
             if (!symbolFilePath)
               throw new Error(`No symbol file path found for ${left.text}.${right.text}`);
             if (property) {
@@ -15564,10 +16146,10 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
             }
           }
         }
-      } else if (ts10.isImportDeclaration(node) && ts10.isStringLiteral(node.moduleSpecifier)) {
+      } else if (ts11.isImportDeclaration(node) && ts11.isStringLiteral(node.moduleSpecifier)) {
         const importPath = node.moduleSpecifier.text;
         if (importPath.startsWith(".")) {
-          const resolved = ts10.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts10.sys).resolvedModule?.resolvedFileName;
+          const resolved = ts11.resolveModuleName(importPath, filePath, program2.getCompilerOptions(), ts11.sys).resolvedModule?.resolvedFileName;
           const moduleName = importPath.split("/").pop()?.split(".")[0] ?? "";
           const property = propertyMap.get(moduleName);
           const isScalar = importPath.includes("_");
@@ -15582,7 +16164,7 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
           }
         }
       }
-      ts10.forEachChild(node, visit);
+      ts11.forEachChild(node, visit);
     }
     visit(source2);
   }
@@ -15674,10 +16256,10 @@ ${document}
 }
 // pkgs/@akanjs/devkit/qualityScanner.ts
 import { createHash } from "crypto";
-import { readdir as readdir3, readFile as readFile3, stat as stat4 } from "fs/promises";
-import path43 from "path";
+import { readdir as readdir4, readFile as readFile4, stat as stat5 } from "fs/promises";
+import path44 from "path";
 import ignore2 from "ignore";
-import ts11 from "typescript";
+import ts12 from "typescript";
 var MAX_FILE_LINES = 2000;
 var PLACEHOLDER_EXPORT_NAMES = new Set([
   "aa",
@@ -15789,7 +16371,7 @@ class AkanQualityScanner {
     const ignoreFilter = ignore2().add(await this.#readGitIgnore(workspaceRoot));
     const files = [];
     for (const targetRoot of ["apps", "libs"]) {
-      const absoluteTargetRoot = path43.join(workspaceRoot, targetRoot);
+      const absoluteTargetRoot = path44.join(workspaceRoot, targetRoot);
       if (!await isDirectory(absoluteTargetRoot))
         continue;
       await this.#walkTargetFiles(workspaceRoot, absoluteTargetRoot, ignoreFilter, files);
@@ -15797,16 +16379,16 @@ class AkanQualityScanner {
     return files.sort();
   }
   async#readGitIgnore(workspaceRoot) {
-    const gitIgnorePath = path43.join(workspaceRoot, ".gitignore");
+    const gitIgnorePath = path44.join(workspaceRoot, ".gitignore");
     if (!await Bun.file(gitIgnorePath).exists())
       return [];
-    return (await readFile3(gitIgnorePath, "utf8")).split(/\r?\n/);
+    return (await readFile4(gitIgnorePath, "utf8")).split(/\r?\n/);
   }
   async#walkTargetFiles(workspaceRoot, currentPath, ignoreFilter, files) {
-    const entries = await readdir3(currentPath, { withFileTypes: true });
+    const entries = await readdir4(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path43.join(currentPath, entry.name);
-      const relativePath = toPosix(path43.relative(workspaceRoot, absolutePath));
+      const absolutePath = path44.join(currentPath, entry.name);
+      const relativePath = toPosix(path44.relative(workspaceRoot, absolutePath));
       if (shouldSkipPath(relativePath, entry.isDirectory(), ignoreFilter))
         continue;
       if (entry.isDirectory()) {
@@ -15819,13 +16401,13 @@ class AkanQualityScanner {
     }
   }
   async#readSourceFile(workspaceRoot, file) {
-    const absolutePath = path43.join(workspaceRoot, file);
-    const content = await readFile3(absolutePath, "utf8");
+    const absolutePath = path44.join(workspaceRoot, file);
+    const content = await readFile4(absolutePath, "utf8");
     return {
       file,
       absolutePath,
       content,
-      sourceFile: ts11.createSourceFile(file, content, ts11.ScriptTarget.Latest, true, getScriptKind(file))
+      sourceFile: ts12.createSourceFile(file, content, ts12.ScriptTarget.Latest, true, getScriptKind(file))
     };
   }
   #scanGlobalQuality(sourceFiles) {
@@ -15950,7 +16532,7 @@ class AkanQualityScanner {
     const suffix = CONVENTION_SUFFIXES.find((candidate) => sourceFile2.file.endsWith(candidate));
     if (!suffix)
       return [];
-    const modelName = toPascalCase(path43.basename(sourceFile2.file, suffix));
+    const modelName = toPascalCase(path44.basename(sourceFile2.file, suffix));
     const warnings = [];
     for (const declaration of getTopLevelDeclarations(sourceFile2)) {
       if (isAllowedConventionDeclaration(suffix, modelName, declaration))
@@ -15961,7 +16543,7 @@ class AkanQualityScanner {
         severity: "warning",
         file: sourceFile2.file,
         line: declaration.line,
-        message: `${path43.basename(sourceFile2.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
+        message: `${path44.basename(sourceFile2.file)} should not declare top-level ${declaration.kind} "${declaration.name}". Allowed declarations: ${getConventionDescription(suffix, modelName)}.`
       });
     }
     return warnings;
@@ -16033,7 +16615,7 @@ function getExportedFunctionLikes(sourceFile2) {
   const declarations = [];
   const nameExempt = isPageRouteFile(sourceFile2.file) || isUiComponentFile(sourceFile2.file);
   for (const statement of sourceFile2.sourceFile.statements) {
-    if (ts11.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
+    if (ts12.isFunctionDeclaration(statement) && statement.name && isExported(statement)) {
       declarations.push({
         name: statement.name.text,
         kind: "function",
@@ -16043,7 +16625,7 @@ function getExportedFunctionLikes(sourceFile2) {
         duplicateNameExempt: nameExempt || isConventionDuplicateNameExempt(sourceFile2.file, false)
       });
     }
-    if (ts11.isClassDeclaration(statement) && statement.name && isExported(statement)) {
+    if (ts12.isClassDeclaration(statement) && statement.name && isExported(statement)) {
       declarations.push({
         name: statement.name.text,
         kind: "class",
@@ -16053,9 +16635,9 @@ function getExportedFunctionLikes(sourceFile2) {
         duplicateNameExempt: nameExempt || isConventionDuplicateNameExempt(sourceFile2.file, isEnumClassStatement(sourceFile2.sourceFile, statement))
       });
     }
-    if (ts11.isVariableStatement(statement) && isExported(statement)) {
+    if (ts12.isVariableStatement(statement) && isExported(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts11.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
+        if (!ts12.isIdentifier(declaration.name) || !isFunctionLikeInitializer(declaration.initializer))
           continue;
         declarations.push({
           name: declaration.name.text,
@@ -16094,14 +16676,14 @@ function isInLibModule(file) {
   return (segments[0] === "apps" || segments[0] === "libs") && segments.includes("lib");
 }
 function isEnumClassStatement(sourceFile2, statement) {
-  if (!ts11.isClassDeclaration(statement))
+  if (!ts12.isClassDeclaration(statement))
     return false;
-  const heritageClause = statement.heritageClauses?.find((clause) => clause.token === ts11.SyntaxKind.ExtendsKeyword);
+  const heritageClause = statement.heritageClauses?.find((clause) => clause.token === ts12.SyntaxKind.ExtendsKeyword);
   const expression = heritageClause?.types[0]?.expression;
   return !!expression && expression.getText(sourceFile2).startsWith("enumOf(");
 }
 function getExportedClassNames(sourceFile2) {
-  return sourceFile2.statements.filter((statement) => ts11.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
+  return sourceFile2.statements.filter((statement) => ts12.isClassDeclaration(statement) && !!statement.name).filter((statement) => isExported(statement)).map((statement) => statement.name.text);
 }
 function isComponentDeclarationFile(file) {
   if (!file.endsWith(".tsx"))
@@ -16117,7 +16699,7 @@ function isComponentDeclarationFile(file) {
 function getComponentFileDeclarations(sourceFile2) {
   const reExportedNames = new Set;
   for (const statement of sourceFile2.statements) {
-    if (ts11.isExportDeclaration(statement) && statement.exportClause && ts11.isNamedExports(statement.exportClause)) {
+    if (ts12.isExportDeclaration(statement) && statement.exportClause && ts12.isNamedExports(statement.exportClause)) {
       for (const element of statement.exportClause.elements)
         reExportedNames.add((element.propertyName ?? element.name).text);
     }
@@ -16127,19 +16709,19 @@ function getComponentFileDeclarations(sourceFile2) {
     const isDefaultExport = isDefaultExportStatement(statement);
     const inlineExported = isExported(statement);
     const add = (name, kind, line) => declarations.push({ name, kind, line, exported: inlineExported || reExportedNames.has(name), isDefaultExport });
-    if (ts11.isInterfaceDeclaration(statement))
+    if (ts12.isInterfaceDeclaration(statement))
       add(statement.name.text, "interface", getLine(sourceFile2, statement));
-    else if (ts11.isTypeAliasDeclaration(statement))
+    else if (ts12.isTypeAliasDeclaration(statement))
       add(statement.name.text, "type", getLine(sourceFile2, statement));
-    else if (ts11.isEnumDeclaration(statement))
+    else if (ts12.isEnumDeclaration(statement))
       add(statement.name.text, "enum", getLine(sourceFile2, statement));
-    else if (ts11.isFunctionDeclaration(statement) && statement.name)
+    else if (ts12.isFunctionDeclaration(statement) && statement.name)
       add(statement.name.text, "function", getLine(sourceFile2, statement));
-    else if (ts11.isClassDeclaration(statement) && statement.name)
+    else if (ts12.isClassDeclaration(statement) && statement.name)
       add(statement.name.text, "class", getLine(sourceFile2, statement));
-    else if (ts11.isVariableStatement(statement)) {
+    else if (ts12.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts11.isIdentifier(declaration.name))
+        if (!ts12.isIdentifier(declaration.name))
           continue;
         const kind = isFunctionLikeInitializer(declaration.initializer) ? "function" : "variable";
         add(declaration.name.text, kind, getLine(sourceFile2, declaration));
@@ -16151,15 +16733,15 @@ function getComponentFileDeclarations(sourceFile2) {
 function getCompoundComponentNames(sourceFile2) {
   const names = new Set;
   for (const statement of sourceFile2.statements) {
-    if (!ts11.isExpressionStatement(statement))
+    if (!ts12.isExpressionStatement(statement))
       continue;
     const { expression } = statement;
-    if (!ts11.isBinaryExpression(expression) || expression.operatorToken.kind !== ts11.SyntaxKind.EqualsToken)
+    if (!ts12.isBinaryExpression(expression) || expression.operatorToken.kind !== ts12.SyntaxKind.EqualsToken)
       continue;
-    if (!ts11.isPropertyAccessExpression(expression.left) || !isPascalCaseName(expression.left.name.text))
+    if (!ts12.isPropertyAccessExpression(expression.left) || !isPascalCaseName(expression.left.name.text))
       continue;
     names.add(expression.left.name.text);
-    if (ts11.isIdentifier(expression.right) && isPascalCaseName(expression.right.text))
+    if (ts12.isIdentifier(expression.right) && isPascalCaseName(expression.right.text))
       names.add(expression.right.text);
   }
   return names;
@@ -16179,9 +16761,9 @@ function isPascalCaseName(name) {
   return /^[A-Z]/.test(name) && !/^[A-Z0-9_]+$/.test(name);
 }
 function isDefaultExportStatement(statement) {
-  if (ts11.isExportAssignment(statement))
+  if (ts12.isExportAssignment(statement))
     return !statement.isExportEquals;
-  return !!(ts11.getCombinedModifierFlags(statement) & ts11.ModifierFlags.Default);
+  return !!(ts12.getCombinedModifierFlags(statement) & ts12.ModifierFlags.Default);
 }
 function getPlaceholderExportWarnings(sourceFile2) {
   if (!sourceFile2.file.endsWith("/index.ts") && !sourceFile2.file.endsWith("/index.tsx"))
@@ -16211,7 +16793,7 @@ function getDictionaryTextWarnings(sourceFile2) {
 function getGlobalMutationWarnings(sourceFile2) {
   const warnings = [];
   for (const statement of sourceFile2.sourceFile.statements) {
-    if (ts11.isModuleDeclaration(statement) && statement.name.getText(sourceFile2.sourceFile) === "global") {
+    if (ts12.isModuleDeclaration(statement) && statement.name.getText(sourceFile2.sourceFile) === "global") {
       warnings.push({
         rule: "akan.file.global-declaration",
         scope: "file",
@@ -16221,7 +16803,7 @@ function getGlobalMutationWarnings(sourceFile2) {
         message: "Global declarations require an explicit low-level integration allowlist."
       });
     }
-    if (ts11.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
+    if (ts12.isInterfaceDeclaration(statement) && statement.name.text === "Window") {
       warnings.push({
         rule: "akan.file.window-augmentation",
         scope: "file",
@@ -16231,7 +16813,7 @@ function getGlobalMutationWarnings(sourceFile2) {
         message: "Window augmentation should be isolated to approved browser integration files."
       });
     }
-    if (ts11.isExpressionStatement(statement) && statement.expression.getText(sourceFile2.sourceFile).includes(".prototype.")) {
+    if (ts12.isExpressionStatement(statement) && statement.expression.getText(sourceFile2.sourceFile).includes(".prototype.")) {
       warnings.push({
         rule: "akan.file.prototype-mutation",
         scope: "file",
@@ -16249,23 +16831,23 @@ function getTopLevelDeclarations(sourceFile2) {
 }
 function getTopLevelDeclaration(sourceFile2, statement) {
   const line = getLine(sourceFile2, statement);
-  if (ts11.isClassDeclaration(statement) && statement.name) {
+  if (ts12.isClassDeclaration(statement) && statement.name) {
     return [{ name: statement.name.text, kind: "class", line, exported: isExported(statement), node: statement }];
   }
-  if (ts11.isFunctionDeclaration(statement) && statement.name) {
+  if (ts12.isFunctionDeclaration(statement) && statement.name) {
     return [{ name: statement.name.text, kind: "function", line, exported: isExported(statement), node: statement }];
   }
-  if (ts11.isInterfaceDeclaration(statement)) {
+  if (ts12.isInterfaceDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "interface", line, exported: isExported(statement), node: statement }];
   }
-  if (ts11.isTypeAliasDeclaration(statement)) {
+  if (ts12.isTypeAliasDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "type", line, exported: isExported(statement), node: statement }];
   }
-  if (ts11.isEnumDeclaration(statement)) {
+  if (ts12.isEnumDeclaration(statement)) {
     return [{ name: statement.name.text, kind: "enum", line, exported: isExported(statement), node: statement }];
   }
-  if (ts11.isVariableStatement(statement)) {
-    return statement.declarationList.declarations.filter((declaration) => ts11.isIdentifier(declaration.name)).map((declaration) => ({
+  if (ts12.isVariableStatement(statement)) {
+    return statement.declarationList.declarations.filter((declaration) => ts12.isIdentifier(declaration.name)).map((declaration) => ({
       name: declaration.name.text,
       kind: "variable",
       line: getLine(sourceFile2, declaration),
@@ -16273,7 +16855,7 @@ function getTopLevelDeclaration(sourceFile2, statement) {
       node: statement
     }));
   }
-  if (ts11.isExportDeclaration(statement)) {
+  if (ts12.isExportDeclaration(statement)) {
     return [{ name: "export declaration", kind: "export", line, exported: true, node: statement }];
   }
   return [];
@@ -16298,9 +16880,9 @@ function isAllowedConstantDeclaration(modelName, declaration) {
     return false;
   if ([`${modelName}Input`, `${modelName}Object`, modelName, `Light${modelName}`, `${modelName}Insight`].includes(declaration.name))
     return true;
-  if (!ts11.isClassDeclaration(declaration.node))
+  if (!ts12.isClassDeclaration(declaration.node))
     return false;
-  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts11.SyntaxKind.ExtendsKeyword);
+  const heritageClause = declaration.node.heritageClauses?.find((clause) => clause.token === ts12.SyntaxKind.ExtendsKeyword);
   const expression = heritageClause?.types[0]?.expression;
   return !!expression && expression.getText().startsWith("enumOf(");
 }
@@ -16366,13 +16948,13 @@ function getModuleInfo(file) {
   return { moduleName, fileName, kind: "database" };
 }
 function isExportedConst(declaration) {
-  return declaration.exported && ts11.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts11.NodeFlags.Const) !== 0;
+  return declaration.exported && ts12.isVariableStatement(declaration.node) && (declaration.node.declarationList.flags & ts12.NodeFlags.Const) !== 0;
 }
 function isExported(node) {
-  return !!ts11.getCombinedModifierFlags(node) && !!(ts11.getCombinedModifierFlags(node) & ts11.ModifierFlags.Export);
+  return !!ts12.getCombinedModifierFlags(node) && !!(ts12.getCombinedModifierFlags(node) & ts12.ModifierFlags.Export);
 }
 function isFunctionLikeInitializer(node) {
-  return !!node && (ts11.isArrowFunction(node) || ts11.isFunctionExpression(node));
+  return !!node && (ts12.isArrowFunction(node) || ts12.isFunctionExpression(node));
 }
 function getBodyFingerprint(sourceFile2, node) {
   if (!node)
@@ -16388,13 +16970,13 @@ function shouldSkipPath(relativePath, isDirectory, ignoreFilter) {
 }
 async function isDirectory(absolutePath) {
   try {
-    return (await stat4(absolutePath)).isDirectory();
+    return (await stat5(absolutePath)).isDirectory();
   } catch {
     return false;
   }
 }
 function getScriptKind(file) {
-  return file.endsWith(".tsx") ? ts11.ScriptKind.TSX : ts11.ScriptKind.TS;
+  return file.endsWith(".tsx") ? ts12.ScriptKind.TSX : ts12.ScriptKind.TS;
 }
 function getLine(sourceFile2, node) {
   return sourceFile2.getLineAndCharacterOfPosition(node.getStart(sourceFile2)).line + 1;
@@ -16415,7 +16997,7 @@ function toPascalCase(value) {
   return value.replace(/(^|[-_./])([a-zA-Z0-9])/g, (_, __, char) => char.toUpperCase()).replace(/[-_./]/g, "");
 }
 function toPosix(value) {
-  return value.split(path43.sep).join("/");
+  return value.split(path44.sep).join("/");
 }
 function groupBy(items, getKey) {
   const grouped = new Map;
@@ -16464,6 +17046,7 @@ class IncrementalBuilder {
   #discovery;
   #changePlanner;
   #generatedIndexSync;
+  #autoImportSync;
   #generation = 0;
   #workQueue = Promise.resolve();
   #cssRebuildQueue = Promise.resolve();
@@ -16478,6 +17061,7 @@ class IncrementalBuilder {
     this.#discovery = options.discovery;
     this.#changePlanner = new DevChangePlanner({ workspaceRoot: options.app.workspace.workspaceRoot });
     this.#generatedIndexSync = new DevGeneratedIndexSync({ workspaceRoot: options.app.workspace.workspaceRoot });
+    this.#autoImportSync = new AutoImportSync({ workspaceRoot: options.app.workspace.workspaceRoot });
   }
   async handleBuildRoute(msg) {
     return this.#enqueueWork(`build-route:${msg.routeId}`, async () => this.#handleBuildRoute(msg));
@@ -16545,10 +17129,10 @@ class IncrementalBuilder {
     }
   }
   batchTouchesPagesTree(appDir, batch) {
-    const absAppDir = path44.resolve(appDir);
+    const absAppDir = path45.resolve(appDir);
     for (const f of batch.files) {
-      const abs = path44.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path44.sep}`) && abs !== absAppDir)
+      const abs = path45.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path45.sep}`) && abs !== absAppDir)
         continue;
       if (/\.(tsx|ts|jsx|js)$/.test(abs))
         return true;
@@ -16556,15 +17140,15 @@ class IncrementalBuilder {
     return false;
   }
   async batchMayChangePageKeys(appDir, batch) {
-    const absAppDir = path44.resolve(appDir);
-    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path44.normalize(key)));
+    const absAppDir = path45.resolve(appDir);
+    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path45.normalize(key)));
     for (const f of batch.files) {
-      const abs = path44.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path44.sep}`) && abs !== absAppDir)
+      const abs = path45.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path45.sep}`) && abs !== absAppDir)
         continue;
       if (!/\.(tsx|ts|jsx|js)$/.test(abs))
         continue;
-      const rel = path44.normalize(path44.relative(absAppDir, abs));
+      const rel = path45.normalize(path45.relative(absAppDir, abs));
       if (!await Bun.file(abs).exists() || !pageKeys.has(rel))
         return true;
     }
@@ -16592,7 +17176,7 @@ class IncrementalBuilder {
 ${cssText}`).toString(36);
           const cssRelPath = `styles/${cssAssetName}-${cssHash}.css`;
           const cssUrl = `/_akan/styles/${cssAssetName}-${cssHash}.css`;
-          await Bun.write(path44.join(artifactDir, cssRelPath), cssText);
+          await Bun.write(path45.join(artifactDir, cssRelPath), cssText);
           cssAssetEntries.push([basePath2, { cssUrl, cssRelPath }]);
           cssBase64ByUrl[cssUrl] = Buffer.from(new TextEncoder().encode(cssText)).toString("base64");
         })()
@@ -16660,10 +17244,10 @@ ${cssText}`).toString(36);
     if (changedFiles.length === 0)
       return false;
     return changedFiles.some((file) => {
-      const normalized = path44.resolve(file);
+      const normalized = path45.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
         return true;
-      return this.#optimizedFonts.files.some((fontFile) => path44.resolve(fontFile) === normalized);
+      return this.#optimizedFonts.files.some((fontFile) => path45.resolve(fontFile) === normalized);
     });
   }
   async installWatcher() {
@@ -16684,6 +17268,11 @@ ${cssText}`).toString(36);
     if (rawKinds.size === 0)
       return;
     const generation = ++this.#generation;
+    const autoImport = await this.#autoImportSync.syncForBatch(batch.files);
+    for (const error of autoImport.errors)
+      this.#logger.error(error);
+    if (autoImport.changedFiles.length > 0)
+      this.#logger.verbose(`[auto-import] inserted imports into ${autoImport.changedFiles.length} file(s)`);
     const indexSync = await this.#generatedIndexSync.syncForBatch(batch.files);
     const { files, kinds, expandedBatch, event, hasSyncErrors } = prepareDevWatchBatch({
       generation,
@@ -16711,14 +17300,18 @@ ${cssText}`).toString(36);
     }
     if (indexSync.changedFiles.length > 0)
       this.#sendBuildStatus("barrel", { generation, ok: true, files });
-    if (kinds.includes("code") && await this.batchMayChangePageKeys(appDir, expandedBatch)) {
+    const rebuildClient = devPlan.actions.includes("rebuild-client");
+    if (kinds.includes("code") && !rebuildClient) {
+      this.#logger.verbose(`client rebuild skipped; devPlan actions=${devPlan.actions.join(",") || "(none)"}`);
+    }
+    if (kinds.includes("code") && rebuildClient && 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, expandedBatch)) {
+    } else if (kinds.includes("code") && rebuildClient && 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()) {
+    if (kinds.includes("code") && rebuildClient && this.#shouldRebuildCsr()) {
       try {
         const started = Date.now();
         await new CsrArtifactBuilder(this.#app).build();
@@ -16729,11 +17322,11 @@ ${cssText}`).toString(36);
         this.#logger.error(`csr-rebundle failed: ${message}`);
         this.#sendBuildStatus("csr", { generation, ok: false, files, message });
       }
-    } else if (kinds.includes("code")) {
+    } else if (kinds.includes("code") && rebuildClient) {
       this.#logger.verbose(`csr-rebundle skipped; set AKAN_DEV_CSR_REBUILD=1 to enable per-save CSR rebuilds`);
     }
     process.send?.(event);
-    if (kinds.includes("code")) {
+    if (kinds.includes("code") && rebuildClient) {
       try {
         const started = Date.now();
         const next = await new PagesBundleBuilder(this.#app).build();
@@ -16768,6 +17361,10 @@ ${cssText}`).toString(36);
           return;
       }
     });
+    process.on("disconnect", () => {
+      this.#logger.warn("host IPC channel closed; exiting builder");
+      process.exit(0);
+    });
     if (this.#watch)
       await this.installWatcher();
     process.send?.({ type: "builder-ready" });