@akanjs/cli 2.3.13 → 2.4.0-rc.1

package/index.js

@@ -4285,9 +4285,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;
@@ -4312,6 +4313,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;
@@ -4560,6 +4563,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);
       },
@@ -4721,6 +4734,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);
@@ -4769,6 +4795,7 @@ ${this.#backendStderrTail.join(`
     this.#sendToBackend(message);
   }
   async#handleInvalidate(message) {
+    this.#logDevPlan(message);
     if (shouldRestartBuilderByDevPlan(message)) {
       try {
         await this.#restartDevChildren(message);
@@ -4880,12 +4907,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();
@@ -8835,7 +8866,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";
@@ -10618,14 +10649,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;
@@ -10667,12 +11222,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;
@@ -10682,31 +11237,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")
@@ -10718,13 +11273,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;
   }
 }
 
@@ -10750,7 +11305,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",
@@ -10782,7 +11337,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";
@@ -10813,8 +11368,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();
@@ -10827,7 +11382,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);
@@ -10869,7 +11424,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))
@@ -10940,16 +11495,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 {
@@ -11002,7 +11557,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;
       }
@@ -11013,7 +11568,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;
       }
@@ -11043,25 +11598,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) {
@@ -11079,7 +11634,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path25.extname(filePath) === ".css";
+    return path26.extname(filePath) === ".css";
   }
 }
 
@@ -11146,7 +11701,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];
@@ -11178,7 +11733,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)
@@ -11204,7 +11759,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),
@@ -11235,11 +11790,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)
@@ -11255,11 +11810,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);
@@ -11301,7 +11856,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;
   }
@@ -11324,19 +11879,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"]);
@@ -11348,11 +11903,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;
@@ -11369,13 +11924,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");
@@ -11396,12 +11951,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");
@@ -11442,15 +11997,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) {
@@ -11475,16 +12030,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$)/;
@@ -11497,7 +12052,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;
@@ -11507,7 +12062,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)
@@ -11520,17 +12075,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;
@@ -11538,32 +12093,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))
@@ -11571,23 +12126,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("."))
@@ -11608,8 +12163,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;
@@ -11621,7 +12176,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)
@@ -11633,12 +12188,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,
@@ -11647,7 +12202,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"];
 
@@ -11662,7 +12217,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();
@@ -11681,7 +12236,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;
@@ -11697,8 +12252,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);
@@ -11712,17 +12267,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)) {
@@ -11733,20 +12288,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)
@@ -11755,13 +12310,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;
   }
@@ -11845,8 +12400,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) {
@@ -11874,7 +12429,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";
@@ -11883,7 +12438,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;
@@ -11893,7 +12448,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());
@@ -11912,7 +12467,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) => {
@@ -12026,7 +12581,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"]);
@@ -12035,10 +12590,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))
@@ -12046,23 +12601,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;
@@ -12075,7 +12630,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;
@@ -12086,7 +12641,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);
@@ -12144,10 +12699,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/"];
@@ -12190,7 +12745,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;
@@ -12202,8 +12757,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;
@@ -12253,7 +12808,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;
   }
@@ -12344,11 +12899,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,
@@ -12430,11 +12985,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) {
@@ -12460,7 +13015,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())
@@ -12478,7 +13033,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;
@@ -12494,7 +13049,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();
@@ -12516,7 +13071,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]])),
@@ -12532,18 +13087,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();
@@ -12580,15 +13135,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(", ")}`);
@@ -12617,14 +13172,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;
@@ -12634,15 +13189,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);
       }
@@ -12709,7 +13264,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 = {}) {
@@ -12717,7 +13272,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 = {}) {
@@ -12789,7 +13344,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 () => {
@@ -12812,14 +13367,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() {
@@ -12836,7 +13391,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",
@@ -12855,7 +13410,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 };
@@ -12881,10 +13436,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())
@@ -12918,7 +13473,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";
@@ -13035,7 +13590,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 };
@@ -13057,17 +13612,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) {
@@ -13150,20 +13705,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())
@@ -13177,7 +13732,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"]));
@@ -13194,14 +13749,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));
     });
   }
@@ -13209,17 +13764,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 {
@@ -13240,9 +13795,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));
     }
   }
@@ -13253,13 +13808,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;
@@ -13308,9 +13863,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";
@@ -13517,13 +14072,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();
@@ -13632,13 +14187,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",
@@ -13851,7 +14406,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,
@@ -13915,10 +14470,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 }
@@ -13933,9 +14488,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();
@@ -14059,7 +14614,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;
@@ -14084,7 +14639,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();
@@ -14111,7 +14666,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"
@@ -14155,7 +14710,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)
     });
   }
@@ -14163,10 +14718,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", [
@@ -14205,7 +14760,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)
@@ -14232,12 +14787,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, "") ?? "";
@@ -14261,7 +14816,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() {
@@ -14269,11 +14824,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
       });
   }
@@ -14281,11 +14836,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 }) {
@@ -14295,7 +14850,7 @@ ${error.message}`;
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path41.posix.join(this.targetRootPath, "assets"),
+      path42.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -14329,13 +14884,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 }) {
@@ -14452,11 +15012,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);
@@ -14498,7 +15080,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">',
@@ -14512,12 +15094,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++) {
@@ -14539,12 +15121,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}"`))
@@ -14563,12 +15145,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) {
@@ -14588,7 +15170,7 @@ ${filter}$1`);
       changed = true;
     }
     if (changed)
-      await writeFile2(manifestPath, manifest);
+      await writeFile3(manifestPath, manifest);
   }
   #setFeaturesInAndroid(features) {
     for (const feature of features) {
@@ -14669,7 +15251,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";
@@ -15173,7 +15755,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))
@@ -15420,7 +16002,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;
@@ -15453,10 +16035,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]);
@@ -15471,7 +16053,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);
@@ -15488,7 +16070,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 {
@@ -15528,17 +16110,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) {
@@ -15562,10 +16144,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("_");
@@ -15580,7 +16162,7 @@ var analyzeProperties = (filesToAnalyze, program2, checker) => {
           }
         }
       }
-      ts10.forEachChild(node, visit);
+      ts11.forEachChild(node, visit);
     }
     visit(source2);
   }
@@ -15672,10 +16254,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",
@@ -15787,7 +16369,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);
@@ -15795,16 +16377,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()) {
@@ -15817,13 +16399,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) {
@@ -15948,7 +16530,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))
@@ -15959,7 +16541,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;
@@ -16031,7 +16613,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",
@@ -16041,7 +16623,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",
@@ -16051,9 +16633,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,
@@ -16092,14 +16674,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"))
@@ -16115,7 +16697,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);
     }
@@ -16125,19 +16707,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));
@@ -16149,15 +16731,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;
@@ -16177,9 +16759,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"))
@@ -16209,7 +16791,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",
@@ -16219,7 +16801,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",
@@ -16229,7 +16811,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",
@@ -16247,23 +16829,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),
@@ -16271,7 +16853,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 [];
@@ -16296,9 +16878,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(");
 }
@@ -16364,13 +16946,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)
@@ -16386,13 +16968,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;
@@ -16413,7 +16995,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;
@@ -17505,7 +18087,7 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
 import { Logger as Logger16 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/package/package.runner.ts
-import path44 from "path";
+import path45 from "path";
 import { Logger as Logger14 } from "akanjs/common";
 var {$: $2 } = globalThis.Bun;
 
@@ -17525,11 +18107,11 @@ class PackageRunner extends runner("package") {
   }
   async#getInstalledPackageJson() {
     const packageJsonCandidates = [
-      `${path44.dirname(Bun.main)}/package.json`,
+      `${path45.dirname(Bun.main)}/package.json`,
       `${process.cwd()}/node_modules/akanjs/package.json`
     ];
     try {
-      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path44.dirname(Bun.main)));
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path45.dirname(Bun.main)));
     } catch {}
     for (const packageJsonPath of packageJsonCandidates) {
       if (!await Bun.file(packageJsonPath).exists())
@@ -17538,7 +18120,7 @@ class PackageRunner extends runner("package") {
       if (packageJson.name === "akanjs" || packageJson.name === "@akanjs/cli")
         return packageJson;
     }
-    throw new Error(`[package] failed to locate akanjs package.json from ${path44.dirname(Bun.main)}`);
+    throw new Error(`[package] failed to locate akanjs package.json from ${path45.dirname(Bun.main)}`);
   }
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
@@ -17713,7 +18295,7 @@ class PackageScript extends script("package", [PackageRunner]) {
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
-import path45 from "path";
+import path46 from "path";
 import { confirm as confirm4, input as input5, select as select8 } from "@inquirer/prompts";
 import { Logger as Logger15, sleep } from "akanjs/common";
 import chalk7 from "chalk";
@@ -17984,7 +18566,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await Promise.all(akanPkgs.map(async (library) => {
       Logger15.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
       await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
-        cwd: path45.join(workspace.workspaceRoot, "dist/pkgs", library),
+        cwd: path46.join(workspace.workspaceRoot, "dist/pkgs", library),
         env: this.#getRegistryEnv(registry),
         stdio: "inherit"
       });
@@ -18038,12 +18620,12 @@ ${chalk7.green("\u27A4")} Authentication Required`));
   async downloadEnv(cloudApi2, workspace, workspaceId) {
     await workspace.mkdir("local");
     const localPath = await cloudApi2.downloadEnv(workspaceId);
-    const relativePath = path45.relative(workspace.workspaceRoot, localPath).split(path45.sep).join("/");
+    const relativePath = path46.relative(workspace.workspaceRoot, localPath).split(path46.sep).join("/");
     await workspace.spawn("tar", ["-xf", relativePath], { cwd: workspace.workspaceRoot });
     await workspace.remove(localPath);
   }
   async uploadEnv(cloudApi2, workspaceId, filePath) {
-    const file = new File([Bun.file(filePath)], path45.basename(filePath));
+    const file = new File([Bun.file(filePath)], path46.basename(filePath));
     await cloudApi2.uploadEnv(workspaceId, file);
   }
   async downloadEnvByScp(workspace) {
@@ -18113,8 +18695,8 @@ ${chalk7.green("\u27A4")} Authentication Required`));
       const secretGlobs = config.secrets ?? [];
       if (secretGlobs.length === 0)
         return [];
-      const appDir = path45.join(workspace.workspaceRoot, "apps", appName);
-      return secretGlobs.flatMap((pattern) => Array.from(new Bun.Glob(pattern).scanSync({ cwd: appDir, onlyFiles: true })).map((match) => `apps/${appName}/${match.split(path45.sep).join("/")}`));
+      const appDir = path46.join(workspace.workspaceRoot, "apps", appName);
+      return secretGlobs.flatMap((pattern) => Array.from(new Bun.Glob(pattern).scanSync({ cwd: appDir, onlyFiles: true })).map((match) => `apps/${appName}/${match.split(path46.sep).join("/")}`));
     }));
     return secretPaths.flat();
   }
@@ -18184,14 +18766,14 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
   async uploadEnv(workspace, { host = GlobalConfig.akanCloudHost } = {}) {
     const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path: path46 } = await this.cloudRunner.gatherEnvFiles(workspace);
+    const { path: path47 } = await this.cloudRunner.gatherEnvFiles(workspace);
     if (workspaceId) {
       await this.login(workspace, host);
       const cloudApi2 = await CloudApi.fromHost(workspace, host);
-      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path46);
+      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path47);
       return;
     }
-    await this.cloudRunner.uploadEnvByScp(workspace, path46);
+    await this.cloudRunner.uploadEnvByScp(workspace, path47);
   }
   async deployAkan(workspace, { test = true, registryUrl } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
@@ -18432,8 +19014,8 @@ class RepairRunner extends runner("repair") {
 }
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
-import { mkdir as mkdir12, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import path46 from "path";
+import { mkdir as mkdir12, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import path47 from "path";
 import { capitalize as capitalize8 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workflows/shared.ts
@@ -18999,7 +19581,7 @@ var workflowSpecs = [
 ];
 
 // pkgs/@akanjs/cli/workflow/workflow.runner.ts
-var resolvePath = (filePath) => path46.isAbsolute(filePath) ? filePath : path46.join(process.cwd(), filePath);
+var resolvePath = (filePath) => path47.isAbsolute(filePath) ? filePath : path47.join(process.cwd(), filePath);
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var isWorkflowPlan2 = (value) => {
   if (!isRecord3(value))
@@ -19097,7 +19679,7 @@ var defaultValidationExecutor = (workspace) => async (command3) => {
     };
   }
 };
-var readJsonFile = async (filePath) => JSON.parse(await readFile4(resolvePath(filePath), "utf8"));
+var readJsonFile = async (filePath) => JSON.parse(await readFile5(resolvePath(filePath), "utf8"));
 var planInputString2 = (plan2, key) => {
   const value = plan2.inputs[key];
   return typeof value === "string" ? value : "";
@@ -19193,8 +19775,8 @@ class WorkflowRunner extends runner("workflow") {
     const plan2 = createWorkflowPlan(spec, compactWorkflowInputs(inputs));
     if (out) {
       const outPath = resolvePath(out);
-      await mkdir12(path46.dirname(outPath), { recursive: true });
-      await writeFile3(outPath, jsonText(plan2));
+      await mkdir12(path47.dirname(outPath), { recursive: true });
+      await writeFile4(outPath, jsonText(plan2));
     }
     return format === "json" ? jsonText(plan2) : renderWorkflowPlan(plan2);
   }
@@ -19212,7 +19794,7 @@ class WorkflowRunner extends runner("workflow") {
     };
     let plan2;
     try {
-      const parsed = JSON.parse(await readFile4(resolvePath(planPath), "utf8"));
+      const parsed = JSON.parse(await readFile5(resolvePath(planPath), "utf8"));
       if (!isWorkflowPlan2(parsed)) {
         const report = failedApplyReport("unknown", [
           {
@@ -21145,7 +21727,7 @@ class ContextScript extends script("context", [ContextRunner]) {
   async doctor(workspace, options = {}) {
     Logger17.rawLog(await this.contextRunner.doctor(workspace, options));
   }
-  async mcpInstall(workspace, target, { force = false, mode = "readonly" } = {}) {
+  async mcpInstall(workspace, target, { force = false, mode = "apply" } = {}) {
     const targets = resolveMcpInstallTargets(target);
     const written = [];
     for (const t of targets) {
@@ -21156,7 +21738,7 @@ class ContextScript extends script("context", [ContextRunner]) {
 ${written.map((line) => `- ${line}`).join(`
 `)}`);
   }
-  async mcp(workspace, { mode = "readonly" } = {}) {
+  async mcp(workspace, { mode = "apply" } = {}) {
     await this.contextRunner.runMcp(workspace, { mode });
   }
   async mcpCall(workspace, tool, {
@@ -21195,7 +21777,7 @@ class ContextCommand extends command("context", [ContextScript], ({ public: targ
   }),
   mcpInstall: target({ desc: "Install the Akan MCP server config for Cursor, Claude Code, and Codex" }).arg("target", String, { desc: "cursor, claude, codex, or all", nullable: true }).option("force", Boolean, { desc: "overwrite an existing Akan MCP server entry", default: false }).option("mode", String, {
     desc: "MCP permission mode",
-    default: "readonly",
+    default: "apply",
     enum: ["readonly", "plan", "apply"]
   }).with(Workspace).exec(async function(targetName, force, mode, workspace) {
     await this.contextScript.mcpInstall(workspace, targetName, {
@@ -21252,14 +21834,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path47 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path47.includes(dir)))
+    for await (const path48 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path48.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path47);
+      const fileContent = await FileSys.readText(path48);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path47);
+      paths.push(path48);
     }
     return paths;
   }
@@ -21579,7 +22161,7 @@ class LibraryCommand extends command("library", [LibraryScript], ({ public: targ
 
 // pkgs/@akanjs/cli/localRegistry/localRegistry.runner.ts
 import { mkdir as mkdir13, rm as rm7 } from "fs/promises";
-import path47 from "path";
+import path48 from "path";
 import { Logger as Logger19 } from "akanjs/common";
 var defaultLocalRegistryUrl = "http://127.0.0.1:4873";
 var containerName = "akan-verdaccio";
@@ -21597,8 +22179,8 @@ class LocalRegistryRunner extends runner("localRegistry") {
       Logger19.info(`Local registry is already running at ${registry}`);
       return registry;
     } catch {}
-    const configPath2 = path47.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
-    const storagePath = path47.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
+    const configPath2 = path48.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
+    const storagePath = path48.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
     await mkdir13(storagePath, { recursive: true });
     await workspace.spawn("docker", [
       "run",
@@ -21621,13 +22203,13 @@ class LocalRegistryRunner extends runner("localRegistry") {
     try {
       await workspace.spawn("docker", ["rm", "-f", containerName], { stdio: "inherit" });
     } catch {}
-    await rm7(path47.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
+    await rm7(path48.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
     Logger19.info("Local registry storage has been reset");
   }
   async smoke(workspace, { registryUrl } = {}) {
     const registry = this.getRegistryUrl(registryUrl);
-    const smokeRoot = path47.join(workspace.workspaceRoot, ".akan/e2e");
-    await rm7(path47.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
+    const smokeRoot = path48.join(workspace.workspaceRoot, ".akan/e2e");
+    await rm7(path48.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
     await workspace.spawn(process.execPath, [
       "dist/pkgs/create-akan-workspace/index.js",
       smokeRepoName,
@@ -21644,12 +22226,12 @@ class LocalRegistryRunner extends runner("localRegistry") {
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["typecheck", smokeAppName], {
-      cwd: path47.join(smokeRoot, smokeRepoName),
+      cwd: path48.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["build", smokeAppName], {
-      cwd: path47.join(smokeRoot, smokeRepoName),
+      cwd: path48.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
@@ -22005,11 +22587,11 @@ class WorkflowCommand extends command("workflow", [WorkflowScript], ({ public: t
 }
 
 // pkgs/@akanjs/cli/workspace/workspace.script.ts
-import path49 from "path";
+import path50 from "path";
 import { Logger as Logger26 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workspace/workspace.runner.ts
-import path48 from "path";
+import path49 from "path";
 var defaultWorkspacePeerDependencies = new Set([
   "@react-spring/web",
   "@use-gesture/react",
@@ -22067,7 +22649,7 @@ class WorkspaceRunner extends runner("workspace") {
     owner = ""
   }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path48.join(cwdPath, dirname2, repoName);
+    const workspaceRoot = path49.join(cwdPath, dirname2, repoName);
     const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname2}/${repoName}...`);
@@ -22123,9 +22705,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getCliPackageJson() {
     const packageJsonCandidates = [
-      path48.join(import.meta.dir, "../package.json"),
-      path48.join(import.meta.dir, "package.json"),
-      path48.join(path48.dirname(Bun.main), "package.json")
+      path49.join(import.meta.dir, "../package.json"),
+      path49.join(import.meta.dir, "package.json"),
+      path49.join(path49.dirname(Bun.main), "package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
@@ -22141,9 +22723,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getAkanPackageJson() {
     const packageJsonCandidates = [
-      path48.join(import.meta.dir, "../../../akanjs/package.json"),
-      path48.join(process.cwd(), "pkgs/akanjs/package.json"),
-      path48.join(path48.dirname(Bun.main), "node_modules/akanjs/package.json")
+      path49.join(import.meta.dir, "../../../akanjs/package.json"),
+      path49.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path49.join(path49.dirname(Bun.main), "node_modules/akanjs/package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
@@ -22157,13 +22739,13 @@ class WorkspaceRunner extends runner("workspace") {
     }
     let current = import.meta.dir;
     for (let depth = 0;depth < 6; depth++) {
-      const packageJsonPath = path48.join(current, "package.json");
+      const packageJsonPath = path49.join(current, "package.json");
       if (await Bun.file(packageJsonPath).exists()) {
         const packageJson = await FileSys.readJson(packageJsonPath);
         if (packageJson.name === "akanjs")
           return packageJson;
       }
-      const parent = path48.dirname(current);
+      const parent = path49.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -22205,14 +22787,18 @@ class WorkspaceScript extends script("workspace", [
   ApplicationScript,
   LibraryScript,
   PackageScript,
-  CloudScript
+  CloudScript,
+  ContextScript,
+  AgentScript
 ]) {
   async createWorkspace(repoName, appName, {
     dirname: dirname2 = ".",
     installLibs = false,
     init = true,
     registryUrl,
-    owner
+    owner,
+    mcpInstall = true,
+    agentInstall = true
   }) {
     const akanVersion = await this.packageScript.version(null, { log: false });
     const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, {
@@ -22233,6 +22819,10 @@ class WorkspaceScript extends script("workspace", [
       dict: { appName },
       options: { libs: installLibs ? ["util", "shared"] : [] }
     });
+    if (agentInstall)
+      await this.agentScript.agent(workspace, "install", "all", { force: true });
+    if (mcpInstall)
+      await this.contextScript.mcpInstall(workspace, "all", { force: true });
     const gitSpinner = workspace.spinning("Initializing git repository and commit...");
     try {
       await workspace.commit("Initial commit", { init: true });
@@ -22240,7 +22830,7 @@ class WorkspaceScript extends script("workspace", [
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath2 = path49.join(dirname2, repoName);
+    const workspacePath2 = path50.join(dirname2, repoName);
     Logger26.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname2}/${repoName}`);
     Logger26.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath2} && akan start ${appName}\` to start the development server.`);
@@ -22331,13 +22921,22 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
     desc: "owner of the workspace",
     default: process.env.GITHUB_OWNER,
     nullable: true
-  }).exec(async function(workspaceName, app, dir, libs, init, registry, owner) {
+  }).option("mcpInstall", Boolean, {
+    desc: "Install the Akan MCP server config for Cursor, Claude Code, and Codex? (Recommended)",
+    default: true
+  }).option("agentInstall", Boolean, {
+    flag: "A",
+    desc: "Install Akan agent rules (AGENTS.md, CLAUDE.md, Cursor)? (Recommended)",
+    default: true
+  }).exec(async function(workspaceName, app, dir, libs, init, registry, owner, mcpInstall, agentInstall) {
     const appName = app || "app";
     await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), {
       dirname: dir,
       installLibs: libs,
       init,
       owner,
+      mcpInstall,
+      agentInstall,
       ...registry ? { registryUrl: registry } : {}
     });
   }),