@akanjs/cli 2.2.10 → 2.2.12

package/incrementalBuilder.proc.js

@@ -2,7 +2,7 @@
 var __require = import.meta.require;
 
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
-import path37 from "path";
+import path38 from "path";
 
 // pkgs/@akanjs/devkit/aiEditor.ts
 import { input, select } from "@inquirer/prompts";
@@ -1723,6 +1723,10 @@ var rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(
 var isAllowedTestFile = (filename) => testFilePattern.test(filename);
 var isAllowedLibRootFile = (filename) => libRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
 var getScanPath = (exec, relativePath) => path5.posix.join(`${exec.type}s`, exec.name, relativePath.split(path5.sep).join("/"));
+var getModuleNameFromPath = (kind, modulePath) => {
+  const dirname = path5.basename(modulePath);
+  return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
+};
 async function assertScanConvention(exec, libRoot) {
   const violations = [];
   const addViolation = (relativePath, reason) => {
@@ -1759,6 +1763,7 @@ ${violations.sort().map((violation) => `- ${violation}`).join(`
 }
 async function validateModuleFiles(exec, violations, kind, modulePath) {
   const { files, dirs } = await exec.getFilesAndDirs(modulePath);
+  const moduleName = getModuleNameFromPath(kind, modulePath);
   dirs.forEach((dirname) => {
     violations.push(`${getScanPath(exec, path5.join(modulePath, dirname))}: unsupported module folder`);
   });
@@ -1766,6 +1771,8 @@ async function validateModuleFiles(exec, violations, kind, modulePath) {
     const filePath = path5.join(modulePath, filename);
     if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
       return;
+    if (filename === `${moduleName}.abstract.md`)
+      return;
     const uiMatch = filename.match(/\.([A-Z][A-Za-z0-9]*)\.tsx$/);
     if (uiMatch) {
       const fileType = uiMatch[1];
@@ -2110,7 +2117,7 @@ class PkgInfo {
   exec;
   name;
   scanResult;
-  static async getScanResult(exec) {
+  static async scanExecutor(exec) {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
     const scanner = await TypeScriptDependencyScanner.from(exec);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
@@ -2132,7 +2139,7 @@ class PkgInfo {
     const existingPkgInfo = PkgInfo.#pkgInfos.get(exec.name);
     if (existingPkgInfo && !options.refresh)
       return existingPkgInfo;
-    const scanResult = await PkgInfo.getScanResult(exec);
+    const scanResult = await PkgInfo.scanExecutor(exec);
     const pkgInfo = new PkgInfo(exec, scanResult);
     PkgInfo.#pkgInfos.set(exec.name, pkgInfo);
     return pkgInfo;
@@ -4460,6 +4467,240 @@ class AkanAppHost {
     this.#builder = null;
   }
 }
+// pkgs/@akanjs/devkit/akanContext.ts
+import { readdir } from "fs/promises";
+import path10 from "path";
+import { capitalize as capitalize2 } from "akanjs/common";
+var generatedFiles = [
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts"
+];
+var appRootAllowFiles = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json"
+]);
+var appRootAllowDirs = new Set([
+  ".akan",
+  "android",
+  "common",
+  "env",
+  "ios",
+  "lib",
+  "page",
+  "private",
+  "public",
+  "script",
+  "srvkit",
+  "ui",
+  "webkit"
+]);
+var safeReadDir = async (dirPath) => {
+  try {
+    return (await readdir(dirPath, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+  } catch {
+    return [];
+  }
+};
+var safeReadText = async (filePath) => {
+  try {
+    return await FileSys.readText(filePath);
+  } catch {
+    return null;
+  }
+};
+var safeReadJson = async (filePath) => {
+  try {
+    return await FileSys.readJson(filePath);
+  } catch {
+    return null;
+  }
+};
+var parseAbstractSummary = (relativePath, content, includeContent) => {
+  if (content === null)
+    return { path: relativePath, exists: false, headings: [] };
+  const headings = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("#")).map((line) => line.replace(/^#+\s*/, "").trim()).filter(Boolean);
+  return {
+    path: relativePath,
+    exists: true,
+    title: headings[0],
+    headings: headings.slice(0, 8),
+    ...includeContent ? { content } : {}
+  };
+};
+var readFiles = async (dirPath) => (await safeReadDir(dirPath)).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
+var getRelative = (workspace, absolutePath) => path10.relative(workspace.workspaceRoot, absolutePath).replaceAll(path10.sep, "/");
+var createModuleContext = async (workspace, sys2, kind, folderName, moduleName, includeAbstractContent) => {
+  const modulePath = kind === "scalar" ? path10.join(sys2.cwdPath, "lib", "__scalar", moduleName) : path10.join(sys2.cwdPath, "lib", folderName);
+  const relativePath = getRelative(workspace, modulePath);
+  const abstractPath = `${relativePath}/${moduleName}.abstract.md`;
+  const abstractContent = await safeReadText(path10.join(workspace.workspaceRoot, abstractPath));
+  return {
+    kind,
+    name: moduleName,
+    folderName,
+    sysName: sys2.name,
+    sysType: sys2.type,
+    path: relativePath,
+    abstract: parseAbstractSummary(abstractPath, abstractContent, includeAbstractContent),
+    files: await readFiles(modulePath)
+  };
+};
+var getSysModules = async (workspace, sys2, {
+  includeAbstractContent = false,
+  module: moduleFilter
+} = {}) => {
+  const libPath = path10.join(sys2.cwdPath, "lib");
+  const entries = await safeReadDir(libPath);
+  const modules = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "__scalar")
+      continue;
+    if (entry.name.startsWith("__"))
+      continue;
+    if (entry.name.startsWith("_")) {
+      const serviceName = entry.name.replace(/^_+/, "");
+      if (moduleFilter && moduleFilter !== serviceName && moduleFilter !== entry.name)
+        continue;
+      if (!await FileSys.fileExists(path10.join(libPath, entry.name, `${serviceName}.service.ts`)))
+        continue;
+      modules.push(await createModuleContext(workspace, sys2, "service", entry.name, serviceName, includeAbstractContent));
+    } else {
+      if (moduleFilter && moduleFilter !== entry.name)
+        continue;
+      if (!await FileSys.fileExists(path10.join(libPath, entry.name, `${entry.name}.constant.ts`)))
+        continue;
+      modules.push(await createModuleContext(workspace, sys2, "domain", entry.name, entry.name, includeAbstractContent));
+    }
+  }
+  const scalarRoot = path10.join(libPath, "__scalar");
+  for (const entry of await safeReadDir(scalarRoot)) {
+    if (!entry.isDirectory() || entry.name.startsWith("_"))
+      continue;
+    if (moduleFilter && moduleFilter !== entry.name)
+      continue;
+    if (!await FileSys.fileExists(path10.join(scalarRoot, entry.name, `${entry.name}.constant.ts`)))
+      continue;
+    modules.push(await createModuleContext(workspace, sys2, "scalar", entry.name, entry.name, includeAbstractContent));
+  }
+  return modules.sort((a, b) => `${a.sysName}:${a.path}`.localeCompare(`${b.sysName}:${b.path}`));
+};
+var getSysContext = async (workspace, type, name, options) => {
+  const sys2 = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
+  return {
+    type,
+    name,
+    path: `${type}s/${name}`,
+    hasConfig: await FileSys.fileExists(path10.join(sys2.cwdPath, "akan.config.ts")),
+    modules: await getSysModules(workspace, sys2, {
+      includeAbstractContent: options.includeAbstractContent,
+      module: options.module
+    })
+  };
+};
+
+class AkanContextAnalyzer {
+  static async analyze(workspace, options = {}) {
+    const [appNames, libNames, pkgNames] = await workspace.getExecs();
+    const rootPackageJson = await safeReadJson(path10.join(workspace.workspaceRoot, "package.json"));
+    const filteredApps = options.app ? appNames.filter((name) => name === options.app) : appNames;
+    const [apps, libs, pkgs] = await Promise.all([
+      Promise.all(filteredApps.map((name) => getSysContext(workspace, "app", name, options))),
+      Promise.all(libNames.map((name) => getSysContext(workspace, "lib", name, options))),
+      Promise.all(pkgNames.map(async (name) => {
+        const packageJson = await safeReadJson(path10.join(workspace.workspaceRoot, "pkgs", name, "package.json"));
+        return {
+          name,
+          path: `pkgs/${name}`,
+          ...packageJson?.version ? { version: packageJson.version } : {}
+        };
+      }))
+    ]);
+    return {
+      schemaVersion: 1,
+      repoName: workspace.repoName,
+      root: workspace.workspaceRoot,
+      packageVersion: rootPackageJson?.dependencies?.akanjs ?? rootPackageJson?.devDependencies?.["@akanjs/devkit"],
+      apps,
+      libs,
+      pkgs,
+      generatedFiles,
+      validationCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>", "akan start <app-name>"]
+    };
+  }
+  static async doctor(workspace, { strict = false } = {}) {
+    const context = await AkanContextAnalyzer.analyze(workspace);
+    const diagnostics = [];
+    for (const app of context.apps) {
+      const appPath = path10.join(workspace.workspaceRoot, app.path);
+      for (const entry of await safeReadDir(appPath)) {
+        const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
+        if (!allowed) {
+          diagnostics.push({
+            severity: "warning",
+            code: "app-root-unknown-entry",
+            path: `${app.path}/${entry.name}`,
+            message: `Unexpected ${entry.isDirectory() ? "folder" : "file"} in app root: ${app.path}/${entry.name}`
+          });
+        }
+      }
+    }
+    for (const sys2 of [...context.apps, ...context.libs]) {
+      for (const module of sys2.modules) {
+        if (!module.abstract.exists) {
+          diagnostics.push({
+            severity: strict ? "error" : "warning",
+            code: "module-abstract-missing",
+            path: module.abstract.path,
+            message: `${capitalize2(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`
+          });
+        }
+      }
+    }
+    return { schemaVersion: 1, strict, diagnostics };
+  }
+  static findModules(context, moduleName) {
+    const modules = [...context.apps, ...context.libs].flatMap((sys2) => sys2.modules);
+    return moduleName ? modules.filter((module) => module.name === moduleName || module.folderName === moduleName) : modules;
+  }
+  static renderMarkdown(context, { module: moduleName } = {}) {
+    const lines = [`# Akan Workspace Context`, "", `- Repo: ${context.repoName}`, `- Root: ${context.root}`];
+    if (context.packageVersion)
+      lines.push(`- Akan version: ${context.packageVersion}`);
+    lines.push("", "## Apps", ...context.apps.map((app) => `- ${app.name}: ${app.modules.length} module(s)`));
+    lines.push("", "## Libraries", ...context.libs.map((lib) => `- ${lib.name}: ${lib.modules.length} module(s)`));
+    lines.push("", "## Packages", ...context.pkgs.map((pkg) => `- ${pkg.name}${pkg.version ? ` (${pkg.version})` : ""}`));
+    const modules = AkanContextAnalyzer.findModules(context, moduleName);
+    lines.push("", "## Modules");
+    for (const module of modules) {
+      lines.push("", `### ${module.sysName}:${module.name} (${module.kind})`, `- Path: ${module.path}`);
+      lines.push(`- Abstract: ${module.abstract.exists ? module.abstract.path : "missing"}`);
+      if (module.abstract.exists && module.abstract.content)
+        lines.push("", module.abstract.content.trim(), "");
+      else if (module.abstract.headings.length)
+        lines.push(`- Abstract headings: ${module.abstract.headings.join(", ")}`);
+      lines.push(`- Files: ${module.files.join(", ") || "none"}`);
+    }
+    lines.push("", "## Validation", ...context.validationCommands.map((command) => `- \`${command}\``));
+    return `${lines.join(`
+`)}
+`;
+  }
+}
 // pkgs/@akanjs/devkit/applicationBuildReporter.ts
 import { Logger as Logger6 } from "akanjs/common";
 
@@ -4506,20 +4747,20 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
 }
 // pkgs/@akanjs/devkit/applicationBuildRunner.ts
 import { mkdir as mkdir7, rm as rm2 } from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/allRoutesBuilder.ts
-import path19 from "path";
+import path20 from "path";
 
 // pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
 import { mkdir as mkdir3 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
 async function appHasStModule(appCwdPath) {
-  return Bun.file(path10.join(appCwdPath, "lib", "st.ts")).exists();
+  return Bun.file(path11.join(appCwdPath, "lib", "st.ts")).exists();
 }
-var IMPLICIT_LAYOUT_DIR = path10.join(".akan", "generated", "root-layouts");
-var IMPLICIT_DICT_DIR = path10.join(".akan", "generated", "dict");
+var IMPLICIT_LAYOUT_DIR = path11.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path11.join(".akan", "generated", "dict");
 function getRootBoundarySegments(key) {
   const match = LAYOUT_KEY_RE.exec(key);
   if (!match)
@@ -4534,10 +4775,10 @@ function implicitRootLayoutKey(segments) {
 }
 function implicitRootLayoutAbsPath(appCwdPath, segments) {
   const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
-  return path10.join(path10.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+  return path11.join(path11.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
 }
 function implicitDictionaryMacroAbsPath(appCwdPath) {
-  return path10.join(path10.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+  return path11.join(path11.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
 }
 function isRootBoundarySegments(segments, basePaths) {
   const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
@@ -4560,7 +4801,7 @@ function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
     const id = segments.join("/");
     boundaries.set(id, {
       sourceKey: key,
-      sourceAbsPath: path10.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      sourceAbsPath: path11.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
       segments
     });
   }
@@ -4578,21 +4819,21 @@ function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
     const segments = getRootBoundarySegments(key);
     return segments !== null && segments.length === 0;
   });
-  return rootLayoutKey ? path10.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+  return rootLayoutKey ? path11.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
 }
 function routePrefixForSegments(segments) {
   const visible = segments.filter((segment) => !/^\(.+\)$/.test(segment));
   return visible[0] ?? null;
 }
 async function assertEnvClientConvention(appCwdPath, appName) {
-  const envPath = path10.join(appCwdPath, "env", "env.client.ts");
+  const envPath = path11.join(appCwdPath, "env", "env.client.ts");
   if (!await Bun.file(envPath).exists()) {
     throw new Error(`[route-convention] app "${appName}" must provide env/env.client.ts exporting "env" for generated System.Provider`);
   }
 }
 async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
   const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
-  await mkdir3(path10.dirname(absPath), { recursive: true });
+  await mkdir3(path11.dirname(absPath), { recursive: true });
   await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
 
 export const allDictionary = getAllDictionary();
@@ -4603,13 +4844,13 @@ async function writeGeneratedRootLayoutFile(opts) {
   await assertEnvClientConvention(opts.appCwdPath, opts.appName);
   const dictMacroAbsPath = opts.includeSystemProvider ? await writeGeneratedDictionaryMacroFile(opts.appCwdPath, opts.appName) : null;
   const absPath = implicitRootLayoutAbsPath(opts.appCwdPath, opts.boundary.segments);
-  await mkdir3(path10.dirname(absPath), { recursive: true });
-  const dictMacroRel = dictMacroAbsPath ? path10.relative(path10.dirname(absPath), dictMacroAbsPath).split(path10.sep).join("/") : null;
+  await mkdir3(path11.dirname(absPath), { recursive: true });
+  const dictMacroRel = dictMacroAbsPath ? path11.relative(path11.dirname(absPath), dictMacroAbsPath).split(path11.sep).join("/") : null;
   const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
-  const sourceRel = opts.boundary.sourceAbsPath ? path10.relative(path10.dirname(absPath), opts.boundary.sourceAbsPath).split(path10.sep).join("/") : null;
+  const sourceRel = opts.boundary.sourceAbsPath ? path11.relative(path11.dirname(absPath), opts.boundary.sourceAbsPath).split(path11.sep).join("/") : null;
   const sourceSpecifier = sourceRel ? sourceRel.startsWith(".") ? sourceRel : `./${sourceRel}` : null;
   const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
-  const inheritedSourceRel = inheritedSourceAbsPath ? path10.relative(path10.dirname(absPath), inheritedSourceAbsPath).split(path10.sep).join("/") : null;
+  const inheritedSourceRel = inheritedSourceAbsPath ? path11.relative(path11.dirname(absPath), inheritedSourceAbsPath).split(path11.sep).join("/") : null;
   const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
   const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
 void st;
@@ -4687,7 +4928,7 @@ export default function GeneratedLayout({ children, params, searchParams }: Layo
   return absPath;
 }
 async function resolveSsrPageEntries(opts) {
-  const absPageDir = path10.resolve(opts.appCwdPath, "page");
+  const absPageDir = path11.resolve(opts.appCwdPath, "page");
   const hasSt = await appHasStModule(opts.appCwdPath);
   const basePaths = opts.basePaths ?? [];
   const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
@@ -4698,7 +4939,7 @@ async function resolveSsrPageEntries(opts) {
   }));
   const base = opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map((key) => ({
     key,
-    moduleAbsPath: path10.resolve(absPageDir, key)
+    moduleAbsPath: path11.resolve(absPageDir, key)
   }));
   const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
     key: implicitRootLayoutKey(boundary.segments),
@@ -4722,14 +4963,14 @@ async function resolveSsrPageEntriesForApp(app, pageKeys) {
 }
 
 // pkgs/@akanjs/devkit/artifact/routeSeedIndex.ts
-import path11 from "path";
+import path12 from "path";
 import { assertUniqueRoutePatterns, compareRouteSpecificity, parseRouteModuleKey as parseRouteModuleKey2 } from "akanjs/common";
 function computeRouteSeedIndex(pageEntries) {
   const layoutsByPrefix = new Map;
   const pagesBySegments = [];
   for (const { key, moduleAbsPath, seedAbsPaths } of pageEntries) {
     const parsed = parseRouteModuleKey2(key);
-    const files = [path11.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path11.resolve(seed))];
+    const files = [path12.resolve(moduleAbsPath), ...(seedAbsPaths ?? []).map((seed) => path12.resolve(seed))];
     if (parsed.kind === "layout") {
       const prefix = parsed.routeSegments.join("/");
       const prev = layoutsByPrefix.get(prefix) ?? [];
@@ -4766,7 +5007,7 @@ function computeRouteSeedIndex(pageEntries) {
 }
 var ROUTE_SEED_INDEX_JSON = "route-seed-index.json";
 function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
-  const normalizedArtifactDir = path11.resolve(artifactDir);
+  const normalizedArtifactDir = path12.resolve(artifactDir);
   if (options.production) {
     return {
       entries: index.entries.map((entry) => ({ routeId: entry.routeId }))
@@ -4781,22 +5022,22 @@ function serializeRouteSeedIndexForArtifact(index, artifactDir, options = {}) {
   };
 }
 async function saveRouteSeedIndex(artifactDir, index, options = {}) {
-  const absPath = path11.join(path11.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
+  const absPath = path12.join(path12.resolve(artifactDir), ROUTE_SEED_INDEX_JSON);
   await Bun.write(absPath, `${JSON.stringify(serializeRouteSeedIndexForArtifact(index, artifactDir, options), null, 2)}
 `);
   return absPath;
 }
 function serializeArtifactPath(artifactPath, artifactDir) {
-  if (!path11.isAbsolute(artifactPath))
+  if (!path12.isAbsolute(artifactPath))
     return artifactPath;
-  return path11.relative(artifactDir, artifactPath).split(path11.sep).join("/");
+  return path12.relative(artifactDir, artifactPath).split(path12.sep).join("/");
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/clientEntryDiscovery.ts
-import path14 from "path";
+import path15 from "path";
 
 // pkgs/@akanjs/devkit/transforms/barrelAnalyzer.ts
-import path12 from "path";
+import path13 from "path";
 import { Logger as Logger7 } from "akanjs/common";
 var REEXPORT_RE = /(?:^|\n)\s*export\s+(?:type\s+)?(?:(\*)(?:\s+as\s+(\w+))?|\{\s*([^}]*?)\s*\})\s+from\s+(["'])([^"']+)\4;?/g;
 var LOCAL_NAMED_RE = /(?:^|\n)\s*export\s+\{\s*([^}]*?)\s*\}(?!\s*from)/g;
@@ -4919,7 +5160,7 @@ class BarrelAnalyzer {
   }
   #scanExports(source, absFile) {
     try {
-      const transpiler = [".tsx", ".jsx"].includes(path12.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
+      const transpiler = [".tsx", ".jsx"].includes(path13.extname(absFile)) ? this.#tsxTranspiler : this.#tsTranspiler;
       const { exports } = transpiler.scan(source);
       return new Set(exports);
     } catch (err) {
@@ -4928,16 +5169,16 @@ class BarrelAnalyzer {
     }
   }
   #subpathFor(pkg, absFile) {
-    const rel = path12.relative(pkg.pkgDir, absFile);
-    if (!rel || rel.startsWith("..") || path12.isAbsolute(rel))
+    const rel = path13.relative(pkg.pkgDir, absFile);
+    if (!rel || rel.startsWith("..") || path13.isAbsolute(rel))
       return null;
     if (pkg.preserveFilePath)
-      return `${pkg.pkgName}/${rel.split(path12.sep).join("/")}`;
+      return `${pkg.pkgName}/${rel.split(path13.sep).join("/")}`;
     const noExt = stripKnownExt(rel);
     const tail = collapseIndex(noExt);
     if (tail === "")
       return pkg.pkgName;
-    return `${pkg.pkgName}/${tail.split(path12.sep).join("/")}`;
+    return `${pkg.pkgName}/${tail.split(path13.sep).join("/")}`;
   }
   async#resolveRel(fromFile, relSpec) {
     if (this.#opts.resolveRelative)
@@ -4978,9 +5219,9 @@ var readIfExists = async (absFile) => {
   return file.text();
 };
 var defaultResolveRelative = async (fromFile, relSpec) => {
-  const baseDir = path12.dirname(fromFile);
-  const joined = path12.resolve(baseDir, relSpec);
-  if (path12.extname(joined)) {
+  const baseDir = path13.dirname(fromFile);
+  const joined = path13.resolve(baseDir, relSpec);
+  if (path13.extname(joined)) {
     if (await Bun.file(joined).exists())
       return joined;
     return null;
@@ -4991,7 +5232,7 @@ var defaultResolveRelative = async (fromFile, relSpec) => {
       return cand;
   }
   for (const ext of CANDIDATE_EXTS) {
-    const cand = path12.join(joined, `index${ext}`);
+    const cand = path13.join(joined, `index${ext}`);
     if (await Bun.file(cand).exists())
       return cand;
   }
@@ -5005,14 +5246,14 @@ var stripKnownExt = (relPath) => {
   return relPath;
 };
 var collapseIndex = (relPathNoExt) => {
-  const parts = relPathNoExt.split(path12.sep);
+  const parts = relPathNoExt.split(path13.sep);
   if (parts[parts.length - 1] === "index")
     parts.pop();
-  return parts.join(path12.sep);
+  return parts.join(path13.sep);
 };
 
 // pkgs/@akanjs/devkit/transforms/barrelImportsPlugin.ts
-import path13 from "path";
+import path14 from "path";
 import ts4 from "typescript";
 var createBarrelImportsPlugin = async (app, { skipPath = defaultSkipPath, pipeAfter } = {}) => {
   const akanConfig2 = await app.getConfig();
@@ -5071,10 +5312,10 @@ var createTsconfigPackageResolver = async (app) => {
       const raw = exact[0];
       if (!raw)
         return null;
-      const entryFile = path13.resolve(app.workspace.workspaceRoot, raw);
+      const entryFile = path14.resolve(app.workspace.workspaceRoot, raw);
       if (!await Bun.file(entryFile).exists())
         return null;
-      const parsed = path13.parse(entryFile);
+      const parsed = path14.parse(entryFile);
       const lastSlash = pkgName.lastIndexOf("/");
       if (parsed.name !== "index" && lastSlash !== -1) {
         const facet = pkgName.slice(lastSlash + 1);
@@ -5083,7 +5324,7 @@ var createTsconfigPackageResolver = async (app) => {
           return { pkgName: parentSpec, entryFile, pkgDir: parsed.dir };
         }
       }
-      return { pkgName, entryFile, pkgDir: path13.dirname(entryFile) };
+      return { pkgName, entryFile, pkgDir: path14.dirname(entryFile) };
     }
     for (const { prefix, replacements } of wildcardEntries) {
       if (!pkgName.startsWith(prefix))
@@ -5093,7 +5334,7 @@ var createTsconfigPackageResolver = async (app) => {
         if (!repl)
           continue;
         const replPath = repl.endsWith("/*") ? repl.slice(0, -1) : repl;
-        const candidate = path13.resolve(app.workspace.workspaceRoot, replPath + suffix);
+        const candidate = path14.resolve(app.workspace.workspaceRoot, replPath + suffix);
         for (const ext of CANDIDATE_EXTS2) {
           const file = `${candidate}${ext}`;
           if (await Bun.file(file).exists()) {
@@ -5101,14 +5342,14 @@ var createTsconfigPackageResolver = async (app) => {
             if (lastSlash !== -1) {
               const parentSpec = pkgName.slice(0, lastSlash);
               if (parentSpec.length > 0) {
-                return { pkgName: parentSpec, entryFile: file, pkgDir: path13.dirname(file) };
+                return { pkgName: parentSpec, entryFile: file, pkgDir: path14.dirname(file) };
               }
             }
-            return { pkgName, entryFile: file, pkgDir: path13.dirname(file) };
+            return { pkgName, entryFile: file, pkgDir: path14.dirname(file) };
           }
         }
         for (const ext of CANDIDATE_EXTS2) {
-          const file = path13.join(candidate, `index${ext}`);
+          const file = path14.join(candidate, `index${ext}`);
           if (await Bun.file(file).exists()) {
             return { pkgName, entryFile: file, pkgDir: candidate };
           }
@@ -5119,16 +5360,16 @@ var createTsconfigPackageResolver = async (app) => {
     const exported = await resolveNodePackageExport(app.workspace.workspaceRoot, pkgName);
     if (exported)
       return exported;
-    const pkgJsonPath = path13.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
+    const pkgJsonPath = path14.join(app.workspace.workspaceRoot, "node_modules", pkgName, "package.json");
     if (!await Bun.file(pkgJsonPath).exists())
       return null;
     try {
       const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
       const rel = pkgJson.module ?? pkgJson.main ?? "index.js";
-      const entryFile = path13.resolve(path13.dirname(pkgJsonPath), rel);
+      const entryFile = path14.resolve(path14.dirname(pkgJsonPath), rel);
       if (!await Bun.file(entryFile).exists())
         return null;
-      return { pkgName, entryFile, pkgDir: path13.dirname(pkgJsonPath) };
+      return { pkgName, entryFile, pkgDir: path14.dirname(pkgJsonPath) };
     } catch {
       return null;
     }
@@ -5142,22 +5383,22 @@ var resolveNodePackageExport = async (workspaceRoot, specifier) => {
   const packageName = getPackageName(specifier);
   if (!packageName)
     return null;
-  const pkgJsonPath = path13.join(workspaceRoot, "node_modules", packageName, "package.json");
+  const pkgJsonPath = path14.join(workspaceRoot, "node_modules", packageName, "package.json");
   if (!await Bun.file(pkgJsonPath).exists())
     return null;
   try {
-    const pkgDir = path13.dirname(pkgJsonPath);
+    const pkgDir = path14.dirname(pkgJsonPath);
     const pkgJson = JSON.parse(await Bun.file(pkgJsonPath).text());
     const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
     const exported = resolvePackageExport(pkgJson.exports, subpath);
     const rel = exported ?? (subpath === "." ? pkgJson.module ?? pkgJson.main ?? "index.js" : null);
     if (!rel || !rel.startsWith("."))
       return null;
-    const entryFile = await resolveFileCandidate(path13.resolve(pkgDir, rel));
+    const entryFile = await resolveFileCandidate(path14.resolve(pkgDir, rel));
     if (!entryFile)
       return null;
     const pkgEntryName = specifier;
-    return { pkgName: pkgEntryName, entryFile, pkgDir: path13.dirname(entryFile), preserveFilePath: true };
+    return { pkgName: pkgEntryName, entryFile, pkgDir: path14.dirname(entryFile), preserveFilePath: true };
   } catch {
     return null;
   }
@@ -5214,7 +5455,7 @@ var getPackageName = (specifier) => {
 var resolveFileCandidate = async (candidate) => {
   if (await Bun.file(candidate).exists())
     return candidate;
-  if (path13.extname(candidate))
+  if (path14.extname(candidate))
     return null;
   for (const ext of CANDIDATE_EXTS2) {
     const file = `${candidate}${ext}`;
@@ -5222,7 +5463,7 @@ var resolveFileCandidate = async (candidate) => {
       return file;
   }
   for (const ext of CANDIDATE_EXTS2) {
-    const file = path13.join(candidate, `index${ext}`);
+    const file = path14.join(candidate, `index${ext}`);
     if (await Bun.file(file).exists())
       return file;
   }
@@ -5436,7 +5677,7 @@ class GraphClientEntryDiscovery {
   }
   invalidate(files) {
     for (const file of files) {
-      const absPath = path14.resolve(file);
+      const absPath = path15.resolve(file);
       this.#readCache.delete(absPath);
       this.#rewriteCache.delete(absPath);
       this.#importCache.delete(absPath);
@@ -5446,7 +5687,7 @@ class GraphClientEntryDiscovery {
       this.#reachableEntriesCache.clear();
   }
   async#fileExists(p) {
-    const absPath = path14.resolve(p);
+    const absPath = path15.resolve(p);
     let cached = this.#fileExistsCache.get(absPath);
     if (!cached) {
       cached = Bun.file(absPath).exists();
@@ -5455,7 +5696,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   #readFile(file) {
-    const absPath = path14.resolve(file);
+    const absPath = path15.resolve(file);
     let cached = this.#readCache.get(absPath);
     if (!cached) {
       cached = Bun.file(absPath).text().catch(() => null);
@@ -5464,7 +5705,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#resolveFileCandidate(absPathNoExt) {
-    const cacheKey = path14.resolve(absPathNoExt);
+    const cacheKey = path15.resolve(absPathNoExt);
     let cached = this.#resolvedFileCache.get(cacheKey);
     if (cached)
       return cached;
@@ -5477,7 +5718,7 @@ class GraphClientEntryDiscovery {
           return f;
       }
       for (const ext of SOURCE_EXTS2) {
-        const f = path14.join(cacheKey, `index${ext}`);
+        const f = path15.join(cacheKey, `index${ext}`);
         if (await this.#fileExists(f))
           return f;
       }
@@ -5493,7 +5734,7 @@ class GraphClientEntryDiscovery {
       return cached;
     cached = (async () => {
       if (spec.startsWith(".") || spec.startsWith("/")) {
-        const abs = spec.startsWith("/") ? spec : path14.resolve(importerDir, spec);
+        const abs = spec.startsWith("/") ? spec : path15.resolve(importerDir, spec);
         return this.#resolveFileCandidate(abs);
       }
       const pkg = await this.#resolvePackage(spec);
@@ -5505,7 +5746,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#getRewrittenSource(file, content) {
-    const absPath = path14.resolve(file);
+    const absPath = path15.resolve(file);
     let cached = this.#rewriteCache.get(absPath);
     if (!cached) {
       cached = (async () => {
@@ -5522,7 +5763,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#getImports(file, source) {
-    const absPath = path14.resolve(file);
+    const absPath = path15.resolve(file);
     let cached = this.#importCache.get(absPath);
     if (!cached) {
       cached = Promise.resolve().then(() => {
@@ -5537,7 +5778,7 @@ class GraphClientEntryDiscovery {
     return cached;
   }
   async#discoverFromFile(file, visiting) {
-    const absPath = path14.resolve(file);
+    const absPath = path15.resolve(file);
     const cached = this.#reachableEntriesCache.get(absPath);
     if (cached)
       return new Set(cached);
@@ -5554,7 +5795,7 @@ class GraphClientEntryDiscovery {
     }
     const source = await this.#getRewrittenSource(absPath, content);
     const imports = await this.#getImports(absPath, source);
-    const importerDir = path14.dirname(absPath);
+    const importerDir = path15.dirname(absPath);
     for (const imp of imports) {
       const spec = imp.path;
       if (!spec)
@@ -5580,14 +5821,14 @@ class GraphClientEntryDiscovery {
 
 // pkgs/@akanjs/devkit/frontendBuild/routeClientBuilder.ts
 import { mkdir as mkdir4 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 
 // pkgs/@akanjs/devkit/transforms/rscUseClientTransform.ts
-import path15 from "path";
+import path16 from "path";
 var USE_CLIENT_RE2 = /^\s*(?:\/\*[\s\S]*?\*\/\s*|\/\/[^\n]*\n\s*)*["']use client["']/;
 var IMPLICIT_ROOT_LAYOUT_RE = /[/\\]\.akan[/\\]generated[/\\](?:implicit-root-layout|root-layouts[/\\].*__root_layout)\.(tsx|ts|jsx|js)$/;
 function toClientReferencePath(absPath, workspaceRoot) {
-  return path15.relative(path15.resolve(workspaceRoot), path15.resolve(absPath)).split(path15.sep).join("/");
+  return path16.relative(path16.resolve(workspaceRoot), path16.resolve(absPath)).split(path16.sep).join("/");
 }
 function transformUseClient(source, args) {
   if (!USE_CLIENT_RE2.test(source))
@@ -5623,7 +5864,7 @@ function loaderFor2(absPath) {
 
 // pkgs/@akanjs/devkit/frontendBuild/clientEntriesBundler.ts
 import fs2 from "fs";
-import path16 from "path";
+import path17 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/clientBuildTypes.ts
 var CLIENT_BUNDLE_NAMING = {
@@ -5712,23 +5953,23 @@ class ClientEntriesBundler {
     };
   }
   async#createOpaqueEntryAliases() {
-    const aliasDir = path16.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
+    const aliasDir = path17.join(this.#app.cwdPath, ".akan", "generated", "client-entry-alias", this.#outputSubdir);
     fs2.mkdirSync(aliasDir, { recursive: true });
     const originalByAlias = new Map;
     const aliasedEntries = await Promise.all(this.#entries.map(async (entry) => {
-      const absEntry = path16.resolve(entry);
+      const absEntry = path17.resolve(entry);
       const hash = Bun.hash(`${this.#app.name}
 ${this.#outputSubdir}
 ${absEntry}`).toString(36);
-      const aliasPath = path16.join(aliasDir, `${hash}.tsx`);
+      const aliasPath = path17.join(aliasDir, `${hash}.tsx`);
       await Bun.write(aliasPath, this.#createOpaqueEntryAliasSource(absEntry, await this.#scanEntryExportNames(absEntry)));
-      originalByAlias.set(path16.resolve(aliasPath), absEntry);
+      originalByAlias.set(path17.resolve(aliasPath), absEntry);
       return aliasPath;
     }));
     return { entries: aliasedEntries, originalByAlias, aliasDir };
   }
   #createOpaqueEntryAliasSource(absEntry, exportNames) {
-    const entryLit = JSON.stringify(path16.resolve(absEntry));
+    const entryLit = JSON.stringify(path17.resolve(absEntry));
     if (exportNames.length === 0)
       return `export * from ${entryLit};
 `;
@@ -5811,16 +6052,16 @@ ${absEntry}`).toString(36);
     return rewritten;
   }
   #toServeUrl(absOutPath) {
-    const rel = path16.relative(this.#outdir, absOutPath).split(path16.sep).join("/");
+    const rel = path17.relative(this.#outdir, absOutPath).split(path17.sep).join("/");
     return `${this.#servePrefix}/${rel}`;
   }
   #absFromOutdir(p) {
-    return path16.isAbsolute(p) ? p : path16.resolve(this.#outdir, p);
+    return path17.isAbsolute(p) ? p : path17.resolve(this.#outdir, p);
   }
   #absFromEntryPoint(p) {
-    if (path16.isAbsolute(p))
-      return path16.resolve(p);
-    const candidates = [path16.resolve(process.cwd(), p), path16.resolve(this.#app.cwdPath, p)];
+    if (path17.isAbsolute(p))
+      return path17.resolve(p);
+    const candidates = [path17.resolve(process.cwd(), p), path17.resolve(this.#app.cwdPath, p)];
     return candidates.find((candidate) => fs2.existsSync(candidate)) ?? candidates[0];
   }
   #collectChunkUrls(absOutPath, visited = new Set) {
@@ -5970,13 +6211,13 @@ class RouteClientBuilder {
       ssrModuleMap[row.id][row.name] = { id: ssrOutput, chunks: [ssrOutput, ssrOutput], name: row.name, async: true };
     }
     for (const entry of bootstrapEntries.buildEntries) {
-      const buildEntry = path17.resolve(entry);
-      const originalEntry = path17.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
+      const buildEntry = path18.resolve(entry);
+      const originalEntry = path18.resolve(bootstrapEntries.originalByBuildEntry.get(buildEntry) ?? buildEntry);
       if (!acceptedEntries.has(originalEntry))
         continue;
       const deps = new Set([originalEntry]);
       for (const dep of browserBundle.entryDepsByAbsPath.get(buildEntry) ?? [])
-        deps.add(path17.resolve(dep));
+        deps.add(path18.resolve(dep));
       const sortedDeps = [...deps].sort();
       clientDepsByEntry[originalEntry] = sortedDeps;
       for (const dep of sortedDeps)
@@ -6028,25 +6269,25 @@ class RouteClientBuilder {
     }).bundle();
   }
   async#createBootstrapEntries(entries) {
-    if (!await Bun.file(path17.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
+    if (!await Bun.file(path18.join(this.#app.cwdPath, "lib", "st.ts")).exists()) {
       return { buildEntries: entries, originalByBuildEntry: new Map };
     }
-    const outdir = path17.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
+    const outdir = path18.join(this.#app.cwdPath, ".akan", "generated", "client-entry-bootstrap");
     await mkdir4(outdir, { recursive: true });
     const originalByBuildEntry = new Map;
     const buildEntries = await Promise.all(entries.map(async (entry) => {
-      const absEntry = path17.resolve(entry);
+      const absEntry = path18.resolve(entry);
       const hash = Bun.hash(`${this.#app.name}
 ${absEntry}`).toString(36);
-      const base = path17.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
-      const wrapperEntry = path17.join(outdir, `${base}-${hash}.tsx`);
+      const base = path18.basename(absEntry).replace(/[^A-Za-z0-9._-]/g, "_");
+      const wrapperEntry = path18.join(outdir, `${base}-${hash}.tsx`);
       const exportNames = await this.#scanExportNames(absEntry);
       await Bun.write(wrapperEntry, RouteClientBuilder.createStoreBootstrapEntrySource({
         appName: this.#app.name,
         originalEntry: absEntry,
         exportNames
       }));
-      originalByBuildEntry.set(path17.resolve(wrapperEntry), absEntry);
+      originalByBuildEntry.set(path18.resolve(wrapperEntry), absEntry);
       return wrapperEntry;
     }));
     return { buildEntries, originalByBuildEntry };
@@ -6098,11 +6339,11 @@ ${defaultNames.map((name) => `export default ${name};`).join(`
     try {
       return Bun.resolveSync("akanjs/server", import.meta.dir);
     } catch {
-      return path17.resolve(import.meta.dir, "../../../server/index.ts");
+      return path18.resolve(import.meta.dir, "../../../server/index.ts");
     }
   }
   static createStoreBootstrapEntrySource(args) {
-    const originalEntry = JSON.stringify(path17.resolve(args.originalEntry));
+    const originalEntry = JSON.stringify(path18.resolve(args.originalEntry));
     const namedExports = args.exportNames.filter((name) => name !== "default");
     const lines = [
       `import ${JSON.stringify(`@apps/${args.appName}/client`)};`,
@@ -6128,7 +6369,7 @@ ${defaultNames.map((name) => `export default ${name};`).join(`
 }
 
 // pkgs/@akanjs/devkit/frontendBuild/routesManifestArtifactSerializer.ts
-import path18 from "path";
+import path19 from "path";
 
 class RoutesManifestArtifactSerializer {
   #manifest;
@@ -6136,7 +6377,7 @@ class RoutesManifestArtifactSerializer {
   #production;
   constructor(manifest, artifactDir, options = {}) {
     this.#manifest = manifest;
-    this.#artifactDir = path18.resolve(artifactDir);
+    this.#artifactDir = path19.resolve(artifactDir);
     this.#production = options.production ?? false;
   }
   static serialize(manifest, artifactDir, options = {}) {
@@ -6169,9 +6410,9 @@ class RoutesManifestArtifactSerializer {
     };
   }
   #serializeArtifactPath(artifactPath) {
-    if (!path18.isAbsolute(artifactPath))
+    if (!path19.isAbsolute(artifactPath))
       return artifactPath;
-    return path18.relative(this.#artifactDir, artifactPath).split(path18.sep).join("/");
+    return path19.relative(this.#artifactDir, artifactPath).split(path19.sep).join("/");
   }
 }
 
@@ -6211,7 +6452,7 @@ class AllRoutesBuilder {
       routeIds: this.#routeIds,
       ...this.#merged
     };
-    const manifestPath = path19.join(path19.resolve(this.#artifactDir), "routes-manifest.json");
+    const manifestPath = path20.join(path20.resolve(this.#artifactDir), "routes-manifest.json");
     await Bun.write(manifestPath, `${JSON.stringify(RoutesManifestArtifactSerializer.serialize(manifest, this.#artifactDir, {
       production: this.#command === "build"
     }), null, 2)}
@@ -6248,11 +6489,11 @@ class AllRoutesBuilder {
 }
 // pkgs/@akanjs/devkit/frontendBuild/csrArtifactBuilder.ts
 import { mkdir as mkdir5, rm, unlink } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/pagesEntrySourceGenerator.ts
 import fs3 from "fs";
-import path20 from "path";
+import path21 from "path";
 import ts5 from "typescript";
 
 class PagesEntrySourceGenerator {
@@ -6265,7 +6506,7 @@ class PagesEntrySourceGenerator {
   }
   generate() {
     const lines = this.#pageEntries.map(({ key, moduleAbsPath }) => {
-      const absPath = path20.resolve(moduleAbsPath);
+      const absPath = path21.resolve(moduleAbsPath);
       return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(absPath)}),`;
     });
     return `export const pages = {
@@ -6279,7 +6520,7 @@ ${lines.join(`
   }
   generateStatic() {
     const imports = this.#pageEntries.map(({ moduleAbsPath }, index) => {
-      const absPath = path20.resolve(moduleAbsPath);
+      const absPath = path21.resolve(moduleAbsPath);
       return `import * as page${index} from ${JSON.stringify(absPath)};`;
     });
     const entries = this.#pageEntries.map(({ key, moduleAbsPath }, index) => {
@@ -6296,7 +6537,7 @@ ${entries.join(`
   }
   static #hasAsyncDefaultExport(moduleAbsPath) {
     try {
-      const source = fs3.readFileSync(path20.resolve(moduleAbsPath), "utf8");
+      const source = fs3.readFileSync(path21.resolve(moduleAbsPath), "utf8");
       const sourceFile = ts5.createSourceFile(moduleAbsPath, source, ts5.ScriptTarget.Latest, true, PagesEntrySourceGenerator.#scriptKind(moduleAbsPath));
       return PagesEntrySourceGenerator.#sourceFileHasAsyncDefaultExport(sourceFile);
     } catch {
@@ -6375,7 +6616,7 @@ class CsrArtifactBuilder {
     const csrBasePaths = [...akanConfig2.basePaths];
     const htmlEntries = csrBasePaths.length > 0 ? csrBasePaths : ["index"];
     await rm(this.#outputDir, { recursive: true, force: true });
-    await mkdir5(path21.join(this.#app.cwdPath, ".akan/generated/csr"), { recursive: true });
+    await mkdir5(path22.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",
@@ -6407,7 +6648,7 @@ ${logs}` : ""}`);
     return { outputDir: this.#outputDir };
   }
   get #outputDir() {
-    return path21.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, this.#command === "build" ? "csr" : ".akan/artifact/csr");
+    return path22.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";
@@ -6438,8 +6679,8 @@ ${logs}` : ""}`);
     ];
   }
   async#loadCsrArtifact() {
-    const artifactDir = path21.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
-    const artifactFile = Bun.file(path21.join(artifactDir, "base-artifact.json"));
+    const artifactDir = path22.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact");
+    const artifactFile = Bun.file(path22.join(artifactDir, "base-artifact.json"));
     if (!await artifactFile.exists())
       return { cssAssets: {} };
     const artifact = await artifactFile.json();
@@ -6452,7 +6693,7 @@ ${logs}` : ""}`);
       const htmlFile = Bun.file(htmlPath);
       if (!await htmlFile.exists())
         continue;
-      const basePath2 = path21.basename(htmlPath, ".html") === "index" ? "" : path21.basename(htmlPath, ".html");
+      const basePath2 = path22.basename(htmlPath, ".html") === "index" ? "" : path22.basename(htmlPath, ".html");
       const inlined = await this.#inlineHtmlAssets(await htmlFile.text(), htmlPath, cssAssets[basePath2]);
       for (const filePath of inlined.jsFiles)
         jsFiles.add(filePath);
@@ -6494,7 +6735,7 @@ ${remainingAssets.join(`
         next = CsrArtifactBuilder.injectBeforeHeadEnd(next, style);
     }
     if (cssAsset) {
-      const cssPath = path21.join(this.#command === "build" ? this.#app.dist.cwdPath : this.#app.cwdPath, ".akan/artifact", cssAsset.cssRelPath);
+      const cssPath = path22.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))
@@ -6565,16 +6806,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 path21.resolve(path21.dirname(htmlPath), normalized);
+    return path22.resolve(path22.dirname(htmlPath), normalized);
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/cssCompiler.ts
-import path23 from "path";
+import path24 from "path";
 import { Logger as Logger8 } from "akanjs/common";
 import { compile } from "tailwindcss";
 
 // pkgs/@akanjs/devkit/frontendBuild/cssImportResolver.ts
-import path22 from "path";
+import path23 from "path";
 var CSS_IMPORT_EXTS = ["", ".css", "/styles.css", "/index.css"];
 
 class CssImportResolver {
@@ -6627,7 +6868,7 @@ class CssImportResolver {
     const exact = this.#paths[id];
     if (exact) {
       for (const repl of exact) {
-        const resolved = await this.#firstExisting(path22.resolve(this.#workspaceRoot, repl));
+        const resolved = await this.#firstExisting(path23.resolve(this.#workspaceRoot, repl));
         if (resolved)
           return resolved;
       }
@@ -6638,7 +6879,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(path22.resolve(this.#workspaceRoot, replPath + suffix));
+        const resolved = await this.#firstExisting(path23.resolve(this.#workspaceRoot, replPath + suffix));
         if (resolved)
           return resolved;
       }
@@ -6668,25 +6909,25 @@ class CssImportResolver {
     try {
       if (!await Bun.file(pkgPath).exists())
         return null;
-      const pkgDir = path22.dirname(pkgPath);
+      const pkgDir = path23.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(path22.resolve(pkgDir, styleEntry));
+      return await this.#firstExisting(path23.resolve(pkgDir, styleEntry));
     } catch {
       return null;
     }
   }
   #resolutionBases(fromBase) {
-    return [fromBase, this.#workspaceRoot, path22.dirname(Bun.main), path22.resolve(path22.dirname(Bun.main), "../..")];
+    return [fromBase, this.#workspaceRoot, path23.dirname(Bun.main), path23.resolve(path23.dirname(Bun.main), "../..")];
   }
   #packageJsonCandidates(pkgName) {
     return [
-      path22.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
-      path22.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
-      path22.join(path22.dirname(Bun.main), "node_modules", pkgName, "package.json"),
-      path22.join(path22.dirname(Bun.main), "../../", pkgName, "package.json")
+      path23.join(this.#workspaceRoot, "pkgs", pkgName, "package.json"),
+      path23.join(this.#workspaceRoot, "node_modules", pkgName, "package.json"),
+      path23.join(path23.dirname(Bun.main), "node_modules", pkgName, "package.json"),
+      path23.join(path23.dirname(Bun.main), "../../", pkgName, "package.json")
     ];
   }
   async#firstExisting(basePath2) {
@@ -6704,7 +6945,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path22.extname(filePath) === ".css";
+    return path23.extname(filePath) === ".css";
   }
 }
 
@@ -6771,7 +7012,7 @@ class CssCompiler {
     pageKeys
   } = {}) {
     pageKeys ??= await this.#app.getPageKeys({ refresh });
-    const seeds = pageKeys.map((key) => path23.resolve(this.#app.cwdPath, "page", key));
+    const seeds = pageKeys.map((key) => path24.resolve(this.#app.cwdPath, "page", key));
     const cssFiles = new Set;
     const sourceFiles = new Set;
     const queue = [...seeds];
@@ -6803,7 +7044,7 @@ class CssCompiler {
       } catch {
         continue;
       }
-      const importerDir = path23.dirname(filePath);
+      const importerDir = path24.dirname(filePath);
       for (const imp of imports) {
         const spec = imp.path;
         if (!spec)
@@ -6829,7 +7070,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 = path23.dirname(cssPath);
+      const base = path24.dirname(cssPath);
       const compiler = await compile(css, {
         base,
         loadStylesheet: (id, fromBase) => this.#loadStylesheet(id, fromBase),
@@ -6860,11 +7101,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: path23.dirname(p), content };
+    return { path: p, base: path24.dirname(p), content };
   }
   async#resolveCssImport(id, fromBase) {
     if (id.startsWith(".") || id.startsWith("/"))
-      return path23.resolve(fromBase, id);
+      return path24.resolve(fromBase, id);
     const resolver = await this.#getCssImportResolver();
     const resolved = await resolver.resolve(id, fromBase);
     if (resolved)
@@ -6880,11 +7121,11 @@ class CssCompiler {
   async#loadModule(id, fromBase) {
     const p = __require.resolve(id, { paths: [fromBase] });
     const mod = await import(p);
-    return { path: p, base: path23.dirname(p), module: mod.default ?? mod };
+    return { path: p, base: path24.dirname(p), module: mod.default ?? mod };
   }
   async#resolveSourceImport(id, fromBase, resolvePackage) {
     if (id.startsWith(".") || id.startsWith("/")) {
-      const abs = id.startsWith("/") ? id : path23.resolve(fromBase, id);
+      const abs = id.startsWith("/") ? id : path24.resolve(fromBase, id);
       return resolveSourceFileCandidate(abs);
     }
     const pkg = await resolvePackage(id);
@@ -6926,7 +7167,7 @@ async function resolveSourceFileCandidate(absPathNoExt) {
       return filePath;
   }
   for (const ext of SOURCE_EXTS3) {
-    const filePath = path23.join(absPathNoExt, `index${ext}`);
+    const filePath = path24.join(absPathNoExt, `index${ext}`);
     if (await Bun.file(filePath).exists())
       return filePath;
   }
@@ -6949,20 +7190,20 @@ function resolveSourceWithRequire(id, fromBase) {
   }
 }
 function isSourceFile(filePath) {
-  return SOURCE_EXTS3.includes(path23.extname(filePath));
+  return SOURCE_EXTS3.includes(path24.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(path23.sep).join("/").replace(/^\.\//, "");
+  const normalized = pageKey.split(path24.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/fontOptimizer.ts
 import { mkdir as mkdir6 } from "fs/promises";
-import path24 from "path";
+import path25 from "path";
 import {
   generateFontFace,
   getMetricsForFamily,
@@ -6986,7 +7227,7 @@ class FontOptimizer {
   constructor(app, command = "start") {
     this.#app = app;
     this.#command = command;
-    this.#artifactRoot = path24.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
+    this.#artifactRoot = path25.join(command === "build" ? app.dist.cwdPath : app.cwdPath, ".akan/artifact");
   }
   async optimize() {
     const fonts = await this.discoverFonts();
@@ -7005,7 +7246,7 @@ class FontOptimizer {
     const pageKeys = await this.#app.getPageKeys();
     const fonts = [];
     await Promise.all(pageKeys.map(async (key) => {
-      const filePath = path24.resolve(this.#app.cwdPath, "page", key);
+      const filePath = path25.resolve(this.#app.cwdPath, "page", key);
       const file = Bun.file(filePath);
       if (!await file.exists())
         return;
@@ -7021,8 +7262,8 @@ class FontOptimizer {
         this.#app.logger.warn(`[font] source not found: ${face.src}`);
         continue;
       }
-      const outputPath = path24.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
-      await mkdir6(path24.dirname(outputPath), { recursive: true });
+      const outputPath = path25.join(this.#artifactRoot, face.optimizedSrc.replace(/^\/_akan\//, ""));
+      await mkdir6(path25.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);
@@ -7169,8 +7410,8 @@ class FontOptimizer {
       return null;
     const rel = src.replace(/^\//, "");
     const candidates = [
-      this.#command === "build" ? path24.join(this.#app.dist.cwdPath, "public", rel) : null,
-      path24.join(this.#app.cwdPath, "public", rel),
+      this.#command === "build" ? path25.join(this.#app.dist.cwdPath, "public", rel) : null,
+      path25.join(this.#app.cwdPath, "public", rel),
       this.#resolveWorkspacePublicPath(rel)
     ].filter(Boolean);
     for (const candidate of candidates) {
@@ -7198,7 +7439,7 @@ class FontOptimizer {
       return "woff2";
     if (signature === "OTTO")
       return "otf";
-    const ext = path24.extname(sourcePath).slice(1).toLowerCase();
+    const ext = path25.extname(sourcePath).slice(1).toLowerCase();
     if (ext === "otf" || ext === "woff" || ext === "woff2")
       return ext;
     return "ttf";
@@ -7207,7 +7448,7 @@ class FontOptimizer {
     const [root, dep, ...rest] = rel.split("/");
     if (root !== "libs" || !dep || rest.length === 0)
       return null;
-    return path24.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
+    return path25.join(this.#app.workspace.workspaceRoot, "libs", dep, "public", ...rest);
   }
   async#getSubsetText(font) {
     const parts = new Set;
@@ -7217,7 +7458,7 @@ class FontOptimizer {
     if (font.subsetText)
       parts.add(font.subsetText);
     for (const filePath of font.subsetFiles ?? []) {
-      const abs = path24.isAbsolute(filePath) ? filePath : path24.join(this.#app.cwdPath, filePath);
+      const abs = path25.isAbsolute(filePath) ? filePath : path25.join(this.#app.cwdPath, filePath);
       const file = Bun.file(abs);
       if (await file.exists())
         parts.add(await file.text());
@@ -7236,7 +7477,7 @@ class FontOptimizer {
     return "";
   }
   async#collectAutoSubsetText() {
-    const roots = ["page", "ui"].map((dir) => path24.join(this.#app.cwdPath, dir));
+    const roots = ["page", "ui"].map((dir) => path25.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) => {
@@ -7350,7 +7591,7 @@ ${declarations.map(([prop, value]) => `  ${prop}: ${value};`).join(`
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path25 from "path";
+import path26 from "path";
 var SOURCE_EXTS4 = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var CSS_EXTS = new Set([".css"]);
 var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
@@ -7359,10 +7600,10 @@ class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path25.basename(abs);
+    const base = path26.basename(abs);
     if (CONFIG_BASENAMES.has(base))
       return "config";
-    const ext = path25.extname(abs).toLowerCase();
+    const ext = path26.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
     if (SOURCE_EXTS4.has(ext))
@@ -7370,23 +7611,23 @@ class HmrChangeClassifier {
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path25.basename(abs);
+    const base = path26.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(`${path25.sep}node_modules${path25.sep}`))
+    if (abs.includes(`${path26.sep}node_modules${path26.sep}`))
       return true;
-    if (abs.includes(`${path25.sep}.akan${path25.sep}`))
+    if (abs.includes(`${path26.sep}.akan${path26.sep}`))
       return true;
     return false;
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs4 from "fs";
-import path26 from "path";
+import path27 from "path";
 class HmrWatcher {
   #roots;
   #debounceMs;
@@ -7399,7 +7640,7 @@ class HmrWatcher {
   #stopped = false;
   #flushing = false;
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path26.resolve(r)))];
+    this.#roots = [...new Set(opts.roots.map((r) => path27.resolve(r)))];
     this.#debounceMs = opts.debounceMs ?? 80;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -7410,7 +7651,7 @@ class HmrWatcher {
         const w = fs4.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path26.resolve(root, filename.toString());
+          const abs = path27.resolve(root, filename.toString());
           this.#queue(abs);
         });
         this.#watchers.push(w);
@@ -7468,10 +7709,10 @@ class HmrWatcher {
   }
 }
 // pkgs/@akanjs/devkit/frontendBuild/pagesBundleBuilder.ts
-import path28 from "path";
+import path29 from "path";
 
 // pkgs/@akanjs/devkit/transforms/externalizeFrameworkPlugin.ts
-import path27 from "path";
+import path28 from "path";
 var DEFAULT_INCLUDE = ["akanjs/", "@apps/", "@libs/"];
 var DEFAULT_EXCLUDE_EXACT = new Set(["akanjs/webkit", "akanjs/server", "@akanjs/cli", "@akanjs/devkit"]);
 var DEFAULT_EXCLUDE_PREFIX = ["akanjs/server/", "@akanjs/cli/", "@akanjs/devkit/"];
@@ -7506,7 +7747,7 @@ async function createExternalizeFrameworkPlugin(options) {
         const replPath = repl?.endsWith("/*") ? repl.slice(0, -1) : repl ?? "";
         if (!replPath)
           continue;
-        const candidate = path27.resolve(workspaceRoot, replPath + suffix);
+        const candidate = path28.resolve(workspaceRoot, replPath + suffix);
         const hit = await firstExisting(candidate);
         if (hit)
           return hit;
@@ -7518,8 +7759,8 @@ async function createExternalizeFrameworkPlugin(options) {
       if (spec === pkg)
         continue;
       const suffix = spec.slice(pkg.length + 1);
-      const pkgDir = path27.dirname(path27.resolve(workspaceRoot, entryFile));
-      const candidate = path27.join(pkgDir, suffix);
+      const pkgDir = path28.dirname(path28.resolve(workspaceRoot, entryFile));
+      const candidate = path28.join(pkgDir, suffix);
       const hit = await firstExisting(candidate);
       if (hit)
         return hit;
@@ -7567,7 +7808,7 @@ async function firstExisting(basePath2) {
       return candidate;
   }
   for (const ext of CANDIDATE_EXTS3) {
-    const candidate = path27.join(basePath2, `index${ext}`);
+    const candidate = path28.join(basePath2, `index${ext}`);
     if (await Bun.file(candidate).exists())
       return candidate;
   }
@@ -7656,11 +7897,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 = path28.resolve(entryArtifact.path);
+    const bundlePath = path29.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] ${path28.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] ${path29.basename(bundlePath)} emitted in ${Date.now() - this.#started}ms splitting=${this.#splitting} entry=${entryArtifact.size} bytes outputs=${result.outputs.length} chunks=${chunkCount} total=${outputBytes} bytes`);
     return {
       bundlePath,
       buildId,
@@ -7703,11 +7944,11 @@ class PagesBundleBuilder {
 }
 // pkgs/@akanjs/devkit/frontendBuild/precompressArtifacts.ts
 import fs5 from "fs";
-import path29 from "path";
+import path30 from "path";
 var COMPRESSIBLE_EXTS = new Set([".css", ".html", ".js", ".json", ".svg"]);
 var MIN_COMPRESS_BYTES = 1024;
 async function precompressArtifacts(app) {
-  const roots = [path29.join(app.dist.cwdPath, ".akan/artifact/client")];
+  const roots = [path30.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) {
@@ -7733,7 +7974,7 @@ async function precompressRoot(root, result) {
 async function shouldPrecompress(filePath) {
   if (filePath.endsWith(".gz"))
     return false;
-  if (!COMPRESSIBLE_EXTS.has(path29.extname(filePath).toLowerCase()))
+  if (!COMPRESSIBLE_EXTS.has(path30.extname(filePath).toLowerCase()))
     return false;
   const file = Bun.file(filePath);
   if (!await file.exists())
@@ -7751,7 +7992,7 @@ function formatBytes(bytes) {
   return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
 }
 // pkgs/@akanjs/devkit/frontendBuild/ssrBaseArtifactBuilder.ts
-import path30 from "path";
+import path31 from "path";
 import { optimize } from "@tailwindcss/node";
 function prepareCssAsset(command, basePath2, cssText) {
   return optimize(cssText, { file: `${basePath2 || "root"}.css`, minify: command === "build" }).code;
@@ -7767,7 +8008,7 @@ class SsrBaseArtifactBuilder {
     this.#app = app;
     this.#command = command;
     this.#artifactDir = `${command === "build" ? app.dist.cwdPath : app.cwdPath}/.akan/artifact`;
-    this.#absArtifactDir = path30.resolve(this.#artifactDir);
+    this.#absArtifactDir = path31.resolve(this.#artifactDir);
   }
   async build() {
     const akanConfig2 = await this.#app.getConfig();
@@ -7787,7 +8028,7 @@ class SsrBaseArtifactBuilder {
       rscClientUrl,
       vendorMap,
       cssAssets,
-      pagesBundlePath: this.#command === "build" ? path30.relative(this.#absArtifactDir, pagesBundle.bundlePath) : pagesBundle.bundlePath,
+      pagesBundlePath: this.#command === "build" ? path31.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]])),
@@ -7796,7 +8037,7 @@ class SsrBaseArtifactBuilder {
       i18n: akanConfig2.i18n,
       imageConfig: akanConfig2.images
     };
-    await Bun.write(path30.join(this.#absArtifactDir, "base-artifact.json"), `${JSON.stringify(artifact, null, 2)}
+    await Bun.write(path31.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 };
@@ -7818,15 +8059,15 @@ class SsrBaseArtifactBuilder {
   async#resolveAkanServerPath() {
     const candidates = [];
     try {
-      candidates.push(path30.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
+      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", this.#app.workspace.workspaceRoot)));
     } catch {}
-    candidates.push(path30.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path30.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
+    candidates.push(path31.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server"), path31.join(this.#app.workspace.workspaceRoot, "node_modules/akanjs/server"));
     try {
-      candidates.push(path30.dirname(Bun.resolveSync("akanjs/server", path30.dirname(Bun.main))));
+      candidates.push(path31.dirname(Bun.resolveSync("akanjs/server", path31.dirname(Bun.main))));
     } catch {}
-    candidates.push(path30.join(path30.dirname(Bun.main), "node_modules/akanjs/server"), path30.join(path30.dirname(Bun.main), "../../akanjs/server"), path30.resolve(import.meta.dir, "../../server"), path30.resolve(import.meta.dir, "../server"));
+    candidates.push(path31.join(path31.dirname(Bun.main), "node_modules/akanjs/server"), path31.join(path31.dirname(Bun.main), "../../akanjs/server"), path31.resolve(import.meta.dir, "../../server"), path31.resolve(import.meta.dir, "../server"));
     for (const candidate of candidates) {
-      if (await Bun.file(path30.join(candidate, "rscClient.tsx")).exists())
+      if (await Bun.file(path31.join(candidate, "rscClient.tsx")).exists())
         return candidate;
     }
     throw new Error(`[base-artifact] failed to locate akanjs/server; looked in: ${candidates.join(", ")}`);
@@ -7855,14 +8096,14 @@ ${preparedCssText}`).toString(36);
       `styles/${cssAssetName}-${cssHash}.css`,
       `/_akan/styles/${cssAssetName}-${cssHash}.css`
     ];
-    await Bun.write(path30.join(this.#absArtifactDir, cssRelPath), preparedCssText);
+    await Bun.write(path31.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 path31 from "path";
+import path32 from "path";
 
 class WatchRootResolver {
   #app;
@@ -7872,15 +8113,15 @@ class WatchRootResolver {
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
     const set = new Set;
-    set.add(path31.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path32.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path31.isAbsolute(target))
+        if (path32.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path31.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path32.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (fs6.existsSync(resolved))
           set.add(resolved);
       }
@@ -7947,7 +8188,7 @@ class ApplicationBuildRunner {
       phases: this.#phases,
       durationMs: Date.now() - this.#startedAt,
       outputDir: this.#app.dist.cwdPath,
-      artifactDir: path32.join(this.#app.dist.cwdPath, ".akan/artifact")
+      artifactDir: path33.join(this.#app.dist.cwdPath, ".akan/artifact")
     };
   }
   async typecheck(options = {}) {
@@ -7955,7 +8196,7 @@ class ApplicationBuildRunner {
     await this.#app.getPageKeys({ refresh: true });
     const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
     if (clean)
-      await rm2(path32.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+      await rm2(path33.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
     await this.#checkProjectInChildProcess(tsconfigPath);
   }
   async#runPhase(id, label, task, summarize, options = {}) {
@@ -7998,6 +8239,7 @@ class ApplicationBuildRunner {
       outdir: this.#app.dist.cwdPath,
       target: "bun",
       minify: true,
+      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
       define: { "process.env.NODE_ENV": JSON.stringify("production") },
       plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
     });
@@ -8011,16 +8253,52 @@ class ApplicationBuildRunner {
       define: { "process.env.NODE_ENV": JSON.stringify("production") },
       plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
     });
+    const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
+      outdir: this.#app.dist.cwdPath,
+      target: "bun",
+      minify: true,
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
+      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+    });
+    await this.#writeConsoleShim();
     return {
-      entrypoints: backendEntryPoints.length + 1,
-      outputs: backendResult.outputs.length + rscWorkerResult.outputs.length
+      entrypoints: backendEntryPoints.length + 2,
+      outputs: backendResult.outputs.length + rscWorkerResult.outputs.length + consoleRuntimeResult.outputs.length + 1
     };
   }
+  async#writeConsoleShim() {
+    await Bun.write(path33.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 () => {
+  assertAkanConsoleAllowed(server.env);
+  await server.start({ listen: false, web: false });
+  try {
+    await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
+  } finally {
+    await server.stop();
+  }
+};
+
+void run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+`);
+  }
   #resolveRscWorkerBuildEntry() {
     try {
       return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
     } catch {
-      return path32.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+    }
+  }
+  #resolveConsoleRuntimeBuildEntry() {
+    try {
+      return path33.join(path33.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+    } catch {
+      return path33.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
     }
   }
   async#buildCsr() {
@@ -8037,7 +8315,7 @@ class ApplicationBuildRunner {
     return { base, allRoutes };
   }
   async#writeTypecheckTsconfig({ incremental = true } = {}) {
-    const typecheckDir = path32.join(this.#app.cwdPath, ".akan", "typecheck");
+    const typecheckDir = path33.join(this.#app.cwdPath, ".akan", "typecheck");
     await mkdir7(typecheckDir, { recursive: true });
     const tsconfig = {
       extends: "../../tsconfig.json",
@@ -8056,7 +8334,7 @@ class ApplicationBuildRunner {
       ],
       references: []
     };
-    const tsconfigPath = path32.join(typecheckDir, "tsconfig.json");
+    const tsconfigPath = path33.join(typecheckDir, "tsconfig.json");
     await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
 `);
     return { typecheckDir, tsconfigPath };
@@ -8082,10 +8360,10 @@ class ApplicationBuildRunner {
   }
   async#resolveTypecheckWorkerEntry() {
     const candidates = [
-      path32.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path32.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path32.join(import.meta.dir, "typecheck.proc.js"),
-      path32.join(import.meta.dir, "typecheck.proc.ts")
+      path33.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path33.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path33.join(import.meta.dir, "typecheck.proc.js"),
+      path33.join(import.meta.dir, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -8261,13 +8539,13 @@ class ApplicationReleasePackager {
     await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
     const libDeps = ["social", "shared", "platform", "util"];
     await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path33) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path33}`;
+    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path34) => {
+      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path34}`;
       if (await FileSys.dirExists(targetPath))
         await rm3(targetPath, { recursive: true, force: true });
     }));
     const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path33) => cp(`${this.#app.workspace.cwdPath}/${path33}`, `${sourceRoot}/${path33}`, { recursive: true })));
+    await Promise.all(syncPaths.map((path34) => cp(`${this.#app.workspace.cwdPath}/${path34}`, `${sourceRoot}/${path34}`, { recursive: true })));
     await this.#writeSourceTsconfig(sourceRoot, libDeps);
     await Bun.write(`${sourceRoot}/README.md`, readme);
     await this.#app.workspace.spawn("tar", [
@@ -8358,20 +8636,20 @@ class ApplicationReleasePackager {
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path33 from "path";
+import path34 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath2) => {
     try {
-      candidates.push(path33.join(path33.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path34.join(path34.dirname(Bun.resolveSync("akanjs/package.json", basePath2)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path33.dirname(Bun.main));
+  addResolvedPackageCandidate(path34.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path33.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path33.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path33.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path33.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path33.join(path33.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path33.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  candidates.push(path34.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.join(path34.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path34.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   for (const candidate of [...new Set(candidates)]) {
     if (await Bun.file(candidate).exists())
       return candidate;
@@ -8381,7 +8659,7 @@ async function resolveSignalTestPreloadPath(target) {
 // pkgs/@akanjs/devkit/builder.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir9 } from "fs/promises";
-import path34 from "path";
+import path35 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"]));
@@ -8398,14 +8676,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(path34.sep);
+      const segments = relativePath.split(path35.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
-    }).map((rel) => path34.join(cwd, rel));
+    }).map((rel) => path35.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(path34.sep);
+      const segments = relativePath.split(path35.sep);
       return !segments.some((segment) => SKIP_ENTRY_DIR_SET.has(segment));
     });
   }
@@ -8413,17 +8691,17 @@ class Builder {
     const out = [];
     for (const p of additionalEntryPoints) {
       if (p.includes("*")) {
-        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path34.sep}`) ? p.slice(cwd.length + 1) : p;
+        const rel = p.startsWith(`${cwd}/`) || p.startsWith(`${cwd}${path35.sep}`) ? p.slice(cwd.length + 1) : p;
         out.push(...this.#globEntrypoints(cwd, rel));
       } else
-        out.push(path34.isAbsolute(p) ? p : path34.join(cwd, p));
+        out.push(path35.isAbsolute(p) ? p : path35.join(cwd, p));
     }
     return out;
   }
   #getBuildOptions({ bundle = false, additionalEntryPoints = [] } = {}) {
     const cwd = this.#executor.cwdPath;
     const entrypoints = [
-      ...bundle ? [path34.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
+      ...bundle ? [path35.join(cwd, "index.ts")] : this.#globEntrypoints(cwd, "**/*.{ts,tsx}"),
       ...this.#resolveAdditionalEntrypoints(cwd, additionalEntryPoints)
     ];
     return {
@@ -8444,9 +8722,9 @@ class Builder {
     for (const relativePath of this.#globFiles(cwd)) {
       if (relativePath === "package.json")
         continue;
-      const sourcePath = path34.join(cwd, relativePath);
-      const targetPath = path34.join(this.#distExecutor.cwdPath, relativePath);
-      await mkdir9(path34.dirname(targetPath), { recursive: true });
+      const sourcePath = path35.join(cwd, relativePath);
+      const targetPath = path35.join(this.#distExecutor.cwdPath, relativePath);
+      await mkdir9(path35.dirname(targetPath), { recursive: true });
       await Bun.write(targetPath, Bun.file(sourcePath));
     }
   }
@@ -8457,13 +8735,13 @@ class Builder {
       return withoutFormatDir;
     if (!hasDotSlash && withoutFormatDir === publishedPath)
       return publishedPath;
-    const parsed = path34.posix.parse(withoutFormatDir);
+    const parsed = path35.posix.parse(withoutFormatDir);
     if (![".js", ".mjs", ".cjs"].includes(parsed.ext))
       return withoutFormatDir;
-    const withoutExt = path34.posix.join(parsed.dir, parsed.name);
+    const withoutExt = path35.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(path34.join(this.#executor.cwdPath, candidate)));
+    const matchedSource = sourceCandidates.find((candidate) => existsSync2(path35.join(this.#executor.cwdPath, candidate)));
     if (!matchedSource)
       return withoutFormatDir;
     return hasDotSlash ? `./${matchedSource}` : matchedSource;
@@ -8513,9 +8791,9 @@ class Builder {
 }
 // pkgs/@akanjs/devkit/capacitorApp.ts
 import { cp as cp2, mkdir as mkdir10, rm as rm4 } from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import { MobileProject } from "@trapezedev/project";
-import { capitalize as capitalize2 } from "akanjs/common";
+import { capitalize as capitalize3 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/fileEditor.ts
 class FileEditor {
@@ -8708,10 +8986,10 @@ class CapacitorApp {
   constructor(app, target) {
     this.app = app;
     this.target = target;
-    this.targetRootPath = path35.posix.join(".akan", "mobile", this.target.name);
-    this.targetRoot = path35.join(this.app.cwdPath, this.targetRootPath);
-    this.targetWebRoot = path35.join(this.targetRoot, "www");
-    this.targetAssetRoot = path35.join(this.targetRoot, "assets");
+    this.targetRootPath = path36.posix.join(".akan", "mobile", this.target.name);
+    this.targetRoot = path36.join(this.app.cwdPath, this.targetRootPath);
+    this.targetWebRoot = path36.join(this.targetRoot, "www");
+    this.targetAssetRoot = path36.join(this.targetRoot, "assets");
     this.project = new MobileProject(this.app.cwdPath, {
       android: { path: this.androidRootPath },
       ios: { path: this.iosProjectPath }
@@ -8727,9 +9005,9 @@ class CapacitorApp {
     await this.#writeCapacitorConfig();
     if (regenerate) {
       if (!platform || platform === "ios")
-        await rm4(path35.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
+        await rm4(path36.join(this.app.cwdPath, this.iosRootPath), { recursive: true, force: true });
       if (!platform || platform === "android")
-        await rm4(path35.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
+        await rm4(path36.join(this.app.cwdPath, this.androidRootPath), { recursive: true, force: true });
     }
     const project = this.project;
     await this.project.load();
@@ -8793,7 +9071,7 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "sync", "android"], { operation, env });
   }
   async#updateAndroidBuildTypes() {
-    const appGradle = await FileEditor.create(path35.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
+    const appGradle = await FileEditor.create(path36.join(this.app.cwdPath, this.androidRootPath, "app/build.gradle"));
     const buildTypesBlock = `
       debug {
         applicationIdSuffix ".debug"
@@ -8836,7 +9114,7 @@ class CapacitorApp {
     const gradleCommand = isWindows ? "gradlew.bat" : "./gradlew";
     await this.app.spawn(gradleCommand, [assembleType === "apk" ? "assembleRelease" : "bundleRelease"], {
       stdio: "inherit",
-      cwd: path35.join(this.app.cwdPath, this.androidRootPath),
+      cwd: path36.join(this.app.cwdPath, this.androidRootPath),
       env: await this.#commandEnv("release", env)
     });
   }
@@ -8844,10 +9122,10 @@ class CapacitorApp {
     await this.#spawnMobile("npx", ["cap", "open", "android"], { operation: "local", env: "local" });
   }
   async#ensureAndroidAssetsDir() {
-    await mkdir10(path35.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
+    await mkdir10(path36.join(this.app.cwdPath, this.androidAssetsPath), { recursive: true });
   }
   async#ensureAndroidDebugKeystore() {
-    const keystorePath = path35.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
+    const keystorePath = path36.join(this.app.cwdPath, this.androidRootPath, "app/debug.keystore");
     if (await Bun.file(keystorePath).exists())
       return;
     await this.#spawn("keytool", [
@@ -8893,12 +9171,12 @@ class CapacitorApp {
     await this.#prepareAndroid({ operation: "release", env: "main" });
   }
   async prepareWww() {
-    const htmlSource = path35.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
+    const htmlSource = path36.join(this.app.dist.cwdPath, "csr", targetHtmlFilename(this.target));
     if (!await Bun.file(htmlSource).exists())
       throw new Error(`CSR html for mobile target '${this.target.name}' not found: ${htmlSource}`);
     await rm4(this.targetWebRoot, { recursive: true, force: true });
     await mkdir10(this.targetWebRoot, { recursive: true });
-    await Bun.write(path35.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
+    await Bun.write(path36.join(this.targetWebRoot, "index.html"), this.#injectMobileTargetMeta(await Bun.file(htmlSource).text()));
   }
   #injectMobileTargetMeta(html) {
     const basePath2 = this.target.basePath?.replace(/^\/+|\/+$/g, "") ?? "";
@@ -8910,7 +9188,7 @@ class CapacitorApp {
   }
   async#writeCapacitorConfig() {
     await mkdir10(this.targetRoot, { recursive: true });
-    const appInfoPath = path35.relative(this.app.cwdPath, path35.join(this.app.cwdPath, "akan.app.json")).split(path35.sep).join("/");
+    const appInfoPath = path36.relative(this.app.cwdPath, path36.join(this.app.cwdPath, "akan.app.json")).split(path36.sep).join("/");
     const content = `import type { AppScanResult } from "akanjs";
 import { withBase } from "${process.env.USE_AKANJS_PKGS === "true" ? "../../pkgs/" : ""}akanjs/capacitor.base.config";
 import appInfo from "${appInfoPath.startsWith(".") ? appInfoPath : `./${appInfoPath}`}";
@@ -8931,18 +9209,18 @@ export default withBase(
   appInfo as AppScanResult,
 );
 `;
-    await Bun.write(path35.join(this.app.cwdPath, "capacitor.config.ts"), content);
+    await Bun.write(path36.join(this.app.cwdPath, "capacitor.config.ts"), content);
   }
   async#prepareTargetAssets() {
     if (!this.target.assets)
       return;
     await mkdir10(this.targetAssetRoot, { recursive: true });
     if (this.target.assets.icon)
-      await cp2(path35.join(this.app.cwdPath, this.target.assets.icon), path35.join(this.targetAssetRoot, "icon.png"), {
+      await cp2(path36.join(this.app.cwdPath, this.target.assets.icon), path36.join(this.targetAssetRoot, "icon.png"), {
         force: true
       });
     if (this.target.assets.splash)
-      await cp2(path35.join(this.app.cwdPath, this.target.assets.splash), path35.join(this.targetAssetRoot, "splash.png"), {
+      await cp2(path36.join(this.app.cwdPath, this.target.assets.splash), path36.join(this.targetAssetRoot, "splash.png"), {
         force: true
       });
   }
@@ -8950,11 +9228,11 @@ export default withBase(
     const files = this.target.files?.[platform];
     if (!files)
       return;
-    const platformRoot = path35.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
+    const platformRoot = path36.join(this.app.cwdPath, platform === "ios" ? this.iosRootPath : this.androidRootPath);
     await Promise.all(Object.entries(files).map(async ([to, from]) => {
-      const targetPath = path35.join(platformRoot, to);
-      await mkdir10(path35.dirname(targetPath), { recursive: true });
-      await cp2(path35.join(this.app.cwdPath, from), targetPath, { force: true });
+      const targetPath = path36.join(platformRoot, to);
+      await mkdir10(path36.dirname(targetPath), { recursive: true });
+      await cp2(path36.join(this.app.cwdPath, from), targetPath, { force: true });
     }));
   }
   async#generateAssets({ operation, env }) {
@@ -8964,7 +9242,7 @@ export default withBase(
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path35.posix.join(this.targetRootPath, "assets"),
+      path36.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -9066,7 +9344,7 @@ export default withBase(
     this.#setPermissionsInAndroid(["POST_NOTIFICATIONS"]);
   }
   async#setPermissionInIos(permissions) {
-    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize2(key)}`, value]));
+    const updateNs = Object.fromEntries(Object.entries(permissions).map(([key, value]) => [`NS${capitalize3(key)}`, value]));
     await Promise.all([
       this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
       this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
@@ -9151,15 +9429,15 @@ var Pkg = createInternalArgToken("Pkg");
 var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path36 from "path";
+import path37 from "path";
 import { confirm, input as input2, select as select2 } from "@inquirer/prompts";
 import { Logger as Logger10 } from "akanjs/common";
 import chalk6 from "chalk";
 import { program } from "commander";
 
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
-var capitalize3 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
-var createDependencyKey = (refName, kind) => `${refName}${capitalize3(kind)}`;
+var capitalize4 = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
+var createDependencyKey = (refName, kind) => `${refName}${capitalize4(kind)}`;
 
 class CommandContainer {
   static #instances = new Map;
@@ -9651,7 +9929,7 @@ var runCommands = async (...commands) => {
     process.exit(1);
   });
   const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path36.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const packageJsonCandidates = [`${path37.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -9927,8 +10205,8 @@ var scanModuleSpecifiers = (source, filePath, includeExports) => {
   return importSpecifiers;
 };
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts7.readConfigFile(tsConfigPath, (path37) => {
-    return ts7.sys.readFile(path37);
+  const configFile = ts7.readConfigFile(tsConfigPath, (path38) => {
+    return ts7.sys.readFile(path38);
   });
   return ts7.parseJsonConfigFileContent(configFile.config, ts7.sys, realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
 };
@@ -10077,10 +10355,7 @@ import { input as input3, select as select3 } from "@inquirer/prompts";
 class Prompter {
   static async#getGuidelineRoot() {
     const dirname2 = getDirname(import.meta.url);
-    const candidates = [
-      `${dirname2}/guidelines`,
-      `${dirname2}/../cli/guidelines`
-    ];
+    const candidates = [`${dirname2}/guidelines`, `${dirname2}/../cli/guidelines`];
     for (const candidate of candidates) {
       try {
         await fsPromise.access(candidate);
@@ -10091,12 +10366,16 @@ class Prompter {
   }
   static async selectGuideline() {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
-    const guideNames = (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_"));
+    const guideNames = await Prompter.listGuidelines();
     return await select3({
       message: "Select a guideline",
       choices: guideNames.map((name) => ({ name, value: name }))
     });
   }
+  static async listGuidelines() {
+    const guidelineRoot = await Prompter.#getGuidelineRoot();
+    return (await fsPromise.readdir(guidelineRoot)).filter((name) => !name.startsWith("_")).sort();
+  }
   static async getGuideJson(guideName) {
     const guidelineRoot = await Prompter.#getGuidelineRoot();
     const filePath = `${guidelineRoot}/${guideName}/${guideName}.generate.json`;
@@ -10241,10 +10520,10 @@ class IncrementalBuilder {
     }
   }
   batchTouchesPagesTree(appDir, batch) {
-    const absAppDir = path37.resolve(appDir);
+    const absAppDir = path38.resolve(appDir);
     for (const f of batch.files) {
-      const abs = path37.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path37.sep}`) && abs !== absAppDir)
+      const abs = path38.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path38.sep}`) && abs !== absAppDir)
         continue;
       if (/\.(tsx|ts|jsx|js)$/.test(abs))
         return true;
@@ -10252,15 +10531,15 @@ class IncrementalBuilder {
     return false;
   }
   async batchMayChangePageKeys(appDir, batch) {
-    const absAppDir = path37.resolve(appDir);
-    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path37.normalize(key)));
+    const absAppDir = path38.resolve(appDir);
+    const pageKeys = new Set((await this.#app.getPageKeys()).map((key) => path38.normalize(key)));
     for (const f of batch.files) {
-      const abs = path37.resolve(f);
-      if (!abs.startsWith(`${absAppDir}${path37.sep}`) && abs !== absAppDir)
+      const abs = path38.resolve(f);
+      if (!abs.startsWith(`${absAppDir}${path38.sep}`) && abs !== absAppDir)
         continue;
       if (!/\.(tsx|ts|jsx|js)$/.test(abs))
         continue;
-      const rel = path37.normalize(path37.relative(absAppDir, abs));
+      const rel = path38.normalize(path38.relative(absAppDir, abs));
       if (!await Bun.file(abs).exists() || !pageKeys.has(rel))
         return true;
     }
@@ -10288,7 +10567,7 @@ class IncrementalBuilder {
 ${cssText}`).toString(36);
           const cssRelPath = `styles/${cssAssetName}-${cssHash}.css`;
           const cssUrl = `/_akan/styles/${cssAssetName}-${cssHash}.css`;
-          await Bun.write(path37.join(artifactDir, cssRelPath), cssText);
+          await Bun.write(path38.join(artifactDir, cssRelPath), cssText);
           cssAssetEntries.push([basePath2, { cssUrl, cssRelPath }]);
           cssBase64ByUrl[cssUrl] = Buffer.from(new TextEncoder().encode(cssText)).toString("base64");
         })()
@@ -10348,10 +10627,10 @@ ${cssText}`).toString(36);
     if (changedFiles.length === 0)
       return false;
     return changedFiles.some((file) => {
-      const normalized = path37.resolve(file);
+      const normalized = path38.resolve(file);
       if (/\.(woff2?|ttf|otf)$/i.test(normalized))
         return true;
-      return this.#optimizedFonts.files.some((fontFile) => path37.resolve(fontFile) === normalized);
+      return this.#optimizedFonts.files.some((fontFile) => path38.resolve(fontFile) === normalized);
     });
   }
   async installWatcher() {