@akanjs/cli 2.2.10-rc.1 → 2.2.11

package/index.js

@@ -1721,6 +1721,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) => {
@@ -1757,6 +1761,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`);
   });
@@ -1764,6 +1769,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];
@@ -2108,7 +2115,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 }));
@@ -2130,7 +2137,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;
@@ -4458,6 +4465,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";
 
@@ -4504,20 +4745,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)
@@ -4532,10 +4773,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));
@@ -4558,7 +4799,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
     });
   }
@@ -4576,21 +4817,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();
@@ -4601,13 +4842,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;
@@ -4685,7 +4926,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);
@@ -4696,7 +4937,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),
@@ -4720,14 +4961,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) ?? [];
@@ -4764,7 +5005,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 }))
@@ -4779,22 +5020,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;
@@ -4917,7 +5158,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) {
@@ -4926,16 +5167,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)
@@ -4976,9 +5217,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;
@@ -4989,7 +5230,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;
   }
@@ -5003,14 +5244,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();
@@ -5069,10 +5310,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);
@@ -5081,7 +5322,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))
@@ -5091,7 +5332,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()) {
@@ -5099,14 +5340,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 };
           }
@@ -5117,16 +5358,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;
     }
@@ -5140,22 +5381,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;
   }
@@ -5212,7 +5453,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}`;
@@ -5220,7 +5461,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;
   }
@@ -5434,7 +5675,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);
@@ -5444,7 +5685,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();
@@ -5453,7 +5694,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);
@@ -5462,7 +5703,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;
@@ -5475,7 +5716,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;
       }
@@ -5491,7 +5732,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);
@@ -5503,7 +5744,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 () => {
@@ -5520,7 +5761,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(() => {
@@ -5535,7 +5776,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);
@@ -5552,7 +5793,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)
@@ -5578,14 +5819,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))
@@ -5621,7 +5862,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 = {
@@ -5710,23 +5951,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};
 `;
@@ -5809,16 +6050,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) {
@@ -5968,13 +6209,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)
@@ -6026,25 +6267,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 };
@@ -6096,11 +6337,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`)};`,
@@ -6126,7 +6367,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;
@@ -6134,7 +6375,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 = {}) {
@@ -6167,9 +6408,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("/");
   }
 }
 
@@ -6209,7 +6450,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)}
@@ -6246,11 +6487,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 {
@@ -6263,7 +6504,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 = {
@@ -6277,7 +6518,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) => {
@@ -6294,7 +6535,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 {
@@ -6373,7 +6614,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",
@@ -6405,7 +6646,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";
@@ -6436,8 +6677,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();
@@ -6450,7 +6691,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);
@@ -6492,7 +6733,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))
@@ -6563,16 +6804,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 {
@@ -6625,7 +6866,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;
       }
@@ -6636,7 +6877,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;
       }
@@ -6666,25 +6907,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) {
@@ -6702,7 +6943,7 @@ class CssImportResolver {
     return parts[0] ?? null;
   }
   static isCssFile(filePath) {
-    return path22.extname(filePath) === ".css";
+    return path23.extname(filePath) === ".css";
   }
 }
 
@@ -6769,7 +7010,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];
@@ -6801,7 +7042,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)
@@ -6827,7 +7068,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),
@@ -6858,11 +7099,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)
@@ -6878,11 +7119,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);
@@ -6924,7 +7165,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;
   }
@@ -6947,20 +7188,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,
@@ -6984,7 +7225,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();
@@ -7003,7 +7244,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;
@@ -7019,8 +7260,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);
@@ -7167,8 +7408,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) {
@@ -7196,7 +7437,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";
@@ -7205,7 +7446,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;
@@ -7215,7 +7456,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());
@@ -7234,7 +7475,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) => {
@@ -7348,7 +7589,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"]);
@@ -7357,10 +7598,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))
@@ -7368,23 +7609,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;
@@ -7397,7 +7638,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;
@@ -7408,7 +7649,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);
@@ -7466,10 +7707,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/"];
@@ -7504,7 +7745,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;
@@ -7516,8 +7757,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;
@@ -7565,7 +7806,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;
   }
@@ -7654,11 +7895,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,
@@ -7701,11 +7942,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) {
@@ -7731,7 +7972,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())
@@ -7749,7 +7990,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;
@@ -7765,7 +8006,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();
@@ -7785,7 +8026,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]])),
@@ -7794,7 +8035,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 };
@@ -7816,15 +8057,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(", ")}`);
@@ -7853,14 +8094,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;
@@ -7870,15 +8111,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);
       }
@@ -7945,7 +8186,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 = {}) {
@@ -7953,7 +8194,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 = {}) {
@@ -7996,6 +8237,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)] : []
     });
@@ -8009,16 +8251,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() {
@@ -8035,7 +8313,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",
@@ -8054,7 +8332,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 };
@@ -8080,10 +8358,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())
@@ -8259,13 +8537,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", [
@@ -8356,20 +8634,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;
@@ -8379,7 +8657,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"]));
@@ -8396,14 +8674,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));
     });
   }
@@ -8411,17 +8689,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 {
@@ -8442,9 +8720,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));
     }
   }
@@ -8455,13 +8733,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;
@@ -8511,9 +8789,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 {
@@ -8706,10 +8984,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 }
@@ -8725,9 +9003,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();
@@ -8791,7 +9069,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"
@@ -8834,7 +9112,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)
     });
   }
@@ -8842,10 +9120,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", [
@@ -8891,12 +9169,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, "") ?? "";
@@ -8908,7 +9186,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}`}";
@@ -8929,18 +9207,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
       });
   }
@@ -8948,11 +9226,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 }) {
@@ -8962,7 +9240,7 @@ export default withBase(
       "@capacitor/assets",
       "generate",
       "--assetPath",
-      path35.posix.join(this.targetRootPath, "assets"),
+      path36.posix.join(this.targetRootPath, "assets"),
       "--iosProject",
       this.iosProjectPath,
       "--androidProject",
@@ -9064,7 +9342,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)
@@ -9149,15 +9427,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;
@@ -9649,7 +9927,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))
@@ -9925,8 +10203,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(/[^/\\]+$/, ""));
 };
@@ -10075,10 +10353,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);
@@ -10089,12 +10364,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`;
@@ -10165,12 +10444,106 @@ import { Box as Box2, Newline, Text as Text2, useInput as useInput2 } from "ink"
 import { useEffect as useEffect3, useState as useState3 } from "react";
 import { jsxDEV as jsxDEV2, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 "use client";
+// pkgs/@akanjs/cli/agent/agent.script.ts
+import { Logger as Logger11 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/agent/agent.runner.ts
+var targetPaths = {
+  cursor: ".cursor/rules/akan.mdc",
+  "agents-md": "AGENTS.md",
+  claude: "CLAUDE.md"
+};
+var targetTitle = {
+  cursor: "Akan Cursor Rules",
+  "agents-md": "Akan Agent Rules",
+  claude: "Akan Claude Rules"
+};
+var renderAgentRules = async (workspace, target) => {
+  const context = await AkanContextAnalyzer.analyze(workspace);
+  const frameworkGuide = await Prompter.getInstruction("framework");
+  return `# ${targetTitle[target]}
+
+This file is generated by \`akan agent install ${target}\`.
+
+## Workspace
+
+- Repo: ${context.repoName}
+- Apps: ${context.apps.map((app) => app.name).join(", ") || "none"}
+- Libraries: ${context.libs.map((lib) => lib.name).join(", ") || "none"}
+- Packages: ${context.pkgs.map((pkg) => pkg.name).join(", ") || "none"}
+
+## Akan Module Abstracts
+
+- Before changing a domain, service, or scalar module, read its \`*.abstract.md\` file first.
+- Update the abstract when business invariants, workflows, or public behavior change.
+- Do not update the abstract for formatting-only, import-only, or style-only changes.
+- Service modules live in \`lib/_<service>\`, but their abstract file is \`<service>.abstract.md\`.
+
+## Generated Files
+
+Do not hand-edit generated registry files such as ${context.generatedFiles.map((file) => `\`${file}\``).join(", ")}.
+
+## Validation
+
+${context.validationCommands.map((command3) => `- \`${command3}\``).join(`
+`)}
+
+## Framework Guide
+
+${frameworkGuide.trim()}
+`;
+};
+
+class AgentRunner extends runner("agent") {
+  async install(workspace, targets, { force = false } = {}) {
+    const written = [];
+    for (const target of targets) {
+      const filePath = targetPaths[target];
+      if (!force && await workspace.exists(filePath)) {
+        throw new Error(`${filePath} already exists. Re-run with --force to overwrite it.`);
+      }
+      const content = await renderAgentRules(workspace, target);
+      await workspace.writeFile(filePath, content, { overwrite: force });
+      written.push(filePath);
+    }
+    return written;
+  }
+}
+
+// pkgs/@akanjs/cli/agent/agent.script.ts
+var resolveTargets = (target) => {
+  if (!target || target === "all")
+    return ["cursor", "agents-md", "claude"];
+  if (target === "cursor" || target === "agents-md" || target === "claude")
+    return [target];
+  throw new Error(`Unknown agent target: ${target}. Use cursor, agents-md, claude, or all.`);
+};
+
+class AgentScript extends script("agent", [AgentRunner]) {
+  async agent(workspace, action, target, { force = false } = {}) {
+    if (action !== "install")
+      throw new Error(`Unknown agent action: ${action}. Use "install".`);
+    const written = await this.agentRunner.install(workspace, resolveTargets(target), { force });
+    Logger11.rawLog(`Agent rules written:
+${written.map((file) => `- ${file}`).join(`
+`)}`);
+  }
+}
+
+// pkgs/@akanjs/cli/agent/agent.command.ts
+class AgentCommand extends command("agent", [AgentScript], ({ public: target }) => ({
+  agent: target({ desc: "Install Akan agent rules for editors and coding agents" }).arg("action", String, { desc: "install" }).arg("target", String, { desc: "cursor, agents-md, claude, or all", nullable: true }).option("force", Boolean, { desc: "overwrite existing rule files", default: false }).with(Workspace).exec(async function(action, targetName, force, workspace) {
+    await this.agentScript.agent(workspace, action, targetName, { force });
+  })
+})) {
+}
+
 // pkgs/@akanjs/cli/application/application.command.ts
 import { select as select6 } from "@inquirer/prompts";
 
 // pkgs/@akanjs/cli/application/application.script.ts
 import { confirm as confirm3 } from "@inquirer/prompts";
-import { Logger as Logger12 } from "akanjs/common";
+import { Logger as Logger13 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/semver.ts
 function parseVersion(version) {
@@ -10288,7 +10661,7 @@ import { StringOutputParser } from "@langchain/core/output_parsers";
 import { PromptTemplate as PromptTemplate2 } from "@langchain/core/prompts";
 import { RunnableSequence as RunnableSequence2 } from "@langchain/core/runnables";
 import { ChatOpenAI as ChatOpenAI3 } from "@langchain/openai";
-import { Logger as Logger11 } from "akanjs/common";
+import { Logger as Logger12 } from "akanjs/common";
 import ora3 from "ora";
 
 // pkgs/@akanjs/cli/openBrowser.ts
@@ -10343,6 +10716,37 @@ class ApplicationRunner extends runner("application") {
       stdio: "inherit"
     });
   }
+  async runConsole(app) {
+    const serverPath = `${app.cwdPath}/server.ts`;
+    if (!await app.exists("server.ts"))
+      throw new Error(`Server file not found: apps/${app.name}/server.ts`);
+    const code = `
+const serverModule = await import(${JSON.stringify(serverPath)});
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("akanjs/server");
+const server = serverModule.server;
+if (!server?.start) throw new Error("server.ts must export server with start()");
+assertAkanConsoleAllowed(server.env);
+await server.start({ listen: false, web: false });
+try {
+  await startAkanConsole(server, {
+    globals: {
+      srv: serverModule.srv,
+      sig: serverModule.sig,
+      db: serverModule.db,
+      cnst: serverModule.cnst,
+      dict: serverModule.dict,
+      option: serverModule.option,
+    },
+  });
+} finally {
+  await server.stop();
+}
+`;
+    await app.spawn("bun", ["-e", code], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console" }),
+      stdio: "inherit"
+    });
+  }
   async typecheck(app, options = {}) {
     await new ApplicationBuildRunner(app).typecheck(options);
   }
@@ -10477,7 +10881,7 @@ class ApplicationRunner extends runner("application") {
       return;
     for (const failure of failures) {
       const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
-      Logger11.rawLog(`Mobile target ${failure.target} failed: ${message}`, undefined, "error");
+      Logger12.rawLog(`Mobile target ${failure.target} failed: ${message}`, undefined, "error");
     }
     throw new Error(`${failures.length}/${results.length} mobile targets failed`);
   }
@@ -10650,6 +11054,10 @@ class ApplicationScript extends script("application", [
     await app.scanSync();
     await this.applicationRunner.runScript(app, scriptFilename);
   }
+  async console(app) {
+    await app.scanSync();
+    await this.applicationRunner.runConsole(app);
+  }
   async build(app, {
     write = true,
     fast = false,
@@ -10657,18 +11065,18 @@ class ApplicationScript extends script("application", [
   } = {}) {
     await app.scanSync({ write });
     if (!quiet)
-      Logger12.rawLog(`Creating an optimized production build for ${app.name}...`);
+      Logger13.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
       const result = await this.applicationRunner.build(app, {
         fast,
         spinner: !quiet
       });
-      Logger12.rawLog(`${app.name} built in dist/apps/${app.name}`);
+      Logger13.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
     } catch (error) {
-      Logger12.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
-      Logger12.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger13.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
+      Logger13.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
@@ -10684,7 +11092,7 @@ class ApplicationScript extends script("application", [
       spinner2.succeed(`${app.name} typechecked`);
     } catch (error) {
       spinner2.fail(`${app.name} typecheck failed`);
-      Logger12.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger13.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
@@ -10866,6 +11274,9 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
   script: target({ desc: "Run a custom script in the application" }).with(App).arg("filename", String, { desc: "name of script", nullable: true }).exec(async function(app, filename) {
     await this.applicationScript.script(app, filename);
   }),
+  console: target({ desc: "Open an interactive server console for the application" }).with(App).exec(async function(app) {
+    await this.applicationScript.console(app);
+  }),
   build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).exec(async function(app, write, fast, quiet) {
     await this.applicationScript.build(app, { write, fast, quiet });
   }),
@@ -10987,11 +11398,11 @@ class ApplicationCommand extends command("application", [ApplicationScript], ({
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
-import { Logger as Logger15 } from "akanjs/common";
+import { Logger as Logger16 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/package/package.runner.ts
-import path37 from "path";
-import { Logger as Logger13 } from "akanjs/common";
+import path38 from "path";
+import { Logger as Logger14 } from "akanjs/common";
 var {$: $2 } = globalThis.Bun;
 
 class PackageRunner extends runner("package") {
@@ -10999,16 +11410,16 @@ class PackageRunner extends runner("package") {
     const pkgJson = process.env.USE_AKANJS_PKGS === "true" ? await FileSys.readJson(`${workspace?.workspaceRoot ?? process.cwd()}/pkgs/akanjs/package.json`) : await this.#getInstalledPackageJson();
     const version = pkgJson.name === "akanjs" ? pkgJson.version : pkgJson.dependencies?.akanjs ?? pkgJson.version;
     if (log)
-      Logger13.rawLog(`akanjs@${version}`);
+      Logger14.rawLog(`akanjs@${version}`);
     return version;
   }
   async#getInstalledPackageJson() {
     const packageJsonCandidates = [
-      `${path37.dirname(Bun.main)}/package.json`,
+      `${path38.dirname(Bun.main)}/package.json`,
       `${process.cwd()}/node_modules/akanjs/package.json`
     ];
     try {
-      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path37.dirname(Bun.main)));
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", path38.dirname(Bun.main)));
     } catch {}
     for (const packageJsonPath of packageJsonCandidates) {
       if (!await Bun.file(packageJsonPath).exists())
@@ -11017,7 +11428,7 @@ class PackageRunner extends runner("package") {
       if (packageJson.name === "akanjs" || packageJson.name === "@akanjs/cli")
         return packageJson;
     }
-    throw new Error(`[package] failed to locate akanjs package.json from ${path37.dirname(Bun.main)}`);
+    throw new Error(`[package] failed to locate akanjs package.json from ${path38.dirname(Bun.main)}`);
   }
   async createPackage(workspace, pkgName) {
     await workspace.applyTemplate({ basePath: `pkgs/${pkgName}`, template: "pkgRoot", dict: { pkgName } });
@@ -11125,9 +11536,9 @@ class PackageScript extends script("package", [PackageRunner]) {
 }
 
 // pkgs/@akanjs/cli/cloud/cloud.runner.ts
-import path38 from "path";
+import path39 from "path";
 import { confirm as confirm4, input as input5, select as select7 } from "@inquirer/prompts";
-import { Logger as Logger14, sleep } from "akanjs/common";
+import { Logger as Logger15, sleep } from "akanjs/common";
 import chalk7 from "chalk";
 import * as QRcode from "qrcode";
 
@@ -11202,7 +11613,7 @@ class CloudRunner extends runner("cloud") {
     const servers = await GlobalConfig.getRemoteEnvServers();
     const serverEntries = Object.entries(servers).sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
     if (serverEntries.length === 0) {
-      Logger14.info("No remote env servers configured. Add the first remote server for SCP mode.");
+      Logger15.info("No remote env servers configured. Add the first remote server for SCP mode.");
       return await this.#addRemoteEnvServer();
     }
     const selectedName = await select7({
@@ -11242,7 +11653,7 @@ class CloudRunner extends runner("cloud") {
     if (!shouldRemove)
       return;
     await GlobalConfig.removeRemoteEnvServer(selectedName);
-    Logger14.info(`Removed remote env server "${selectedName}"`);
+    Logger15.info(`Removed remote env server "${selectedName}"`);
   }
   async#getRemoteEnvServerWithUsername() {
     const remoteServer = await this.#selectRemoteEnvServer();
@@ -11283,17 +11694,17 @@ class CloudRunner extends runner("cloud") {
     const cloudApi2 = new CloudApi(workspace, config);
     const self = config.auth ? await cloudApi2.getRemoteSelf() : null;
     if (self) {
-      Logger14.rawLog(chalk7.green(`
+      Logger15.rawLog(chalk7.green(`
 \u2713 Already logged in akan cloud as ${self.nickname}
 `));
       return true;
     }
     const remoteId = crypto.randomUUID();
     const signinUrl = `${cloudApi2.host}/remoteAuth?remoteId=${encodeURIComponent(remoteId)}`;
-    Logger14.rawLog(chalk7.bold(`
+    Logger15.rawLog(chalk7.bold(`
 ${chalk7.green("\u27A4")} Authentication Required`));
-    Logger14.rawLog(chalk7.dim("Please visit or click the following URL:"));
-    Logger14.rawLog(`${chalk7.cyan.underline(signinUrl)}
+    Logger15.rawLog(chalk7.dim("Please visit or click the following URL:"));
+    Logger15.rawLog(`${chalk7.cyan.underline(signinUrl)}
 `);
     try {
       const qrcode = await new Promise((resolve, reject) => {
@@ -11303,23 +11714,23 @@ ${chalk7.green("\u27A4")} Authentication Required`));
           resolve(data);
         });
       });
-      Logger14.rawLog(qrcode);
+      Logger15.rawLog(qrcode);
       await openBrowser(signinUrl);
-      Logger14.rawLog(chalk7.dim("Opening browser..."));
+      Logger15.rawLog(chalk7.dim("Opening browser..."));
     } catch {
-      Logger14.rawLog(chalk7.yellow("Could not open browser. Please visit the URL manually."));
+      Logger15.rawLog(chalk7.yellow("Could not open browser. Please visit the URL manually."));
     }
-    Logger14.rawLog(chalk7.dim("Waiting for authentication..."));
+    Logger15.rawLog(chalk7.dim("Waiting for authentication..."));
     const MAX_RETRY = 300;
     for (let i = 0;i < MAX_RETRY; i++) {
       const accessToken = await cloudApi2.getRemoteAuthToken(remoteId);
       const self2 = await cloudApi2.getRemoteSelf();
       if (accessToken && self2) {
         await GlobalConfig.setHostConfig({ host: config.host, auth: { accessToken, self: self2 } });
-        Logger14.rawLog(chalk7.green(`\r\u2713 Authentication successful!`));
-        Logger14.rawLog(chalk7.green.bold(`
+        Logger15.rawLog(chalk7.green(`\r\u2713 Authentication successful!`));
+        Logger15.rawLog(chalk7.green.bold(`
 \u2728 Welcome aboard, ${self2.nickname ?? "anonymous"}!`));
-        Logger14.rawLog(chalk7.dim(`You're now ready to use Akan CLI!
+        Logger15.rawLog(chalk7.dim(`You're now ready to use Akan CLI!
 `));
         return true;
       }
@@ -11331,17 +11742,17 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     const config = await GlobalConfig.getHostConfig(host);
     if (config.auth?.self) {
       await GlobalConfig.setHostConfig(getDefaultHostConfig(config.host));
-      Logger14.rawLog(chalk7.magenta.bold(`
+      Logger15.rawLog(chalk7.magenta.bold(`
 \uD83D\uDC4B Goodbye, ${config.auth.self.nickname ?? "anonymous"}!`));
-      Logger14.rawLog(chalk7.dim(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+      Logger15.rawLog(chalk7.dim(`\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
 `));
-      Logger14.rawLog(chalk7.cyan("You have been successfully logged out."));
-      Logger14.rawLog(chalk7.dim(`Thank you for using Akan CLI. Come back soon! \uD83C\uDF1F
+      Logger15.rawLog(chalk7.cyan("You have been successfully logged out."));
+      Logger15.rawLog(chalk7.dim(`Thank you for using Akan CLI. Come back soon! \uD83C\uDF1F
 `));
     } else {
-      Logger14.rawLog(chalk7.yellow.bold(`
+      Logger15.rawLog(chalk7.yellow.bold(`
 \u26A0\uFE0F  No active session found`));
-      Logger14.rawLog(chalk7.dim(`You were not logged in to begin with
+      Logger15.rawLog(chalk7.dim(`You were not logged in to begin with
 `));
     }
   }
@@ -11350,7 +11761,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
   }
   resetLlm() {
     AiSession.setLlmConfig(null);
-    Logger14.rawLog(chalk7.green("\u2611\uFE0F LLM model config is cleared. Please run `akan set-llm` to set a new LLM model."));
+    Logger15.rawLog(chalk7.green("\u2611\uFE0F LLM model config is cleared. Please run `akan set-llm` to set a new LLM model."));
   }
   async getAkanPkgs(workspace) {
     const pkgs = await workspace.getPkgs();
@@ -11374,8 +11785,8 @@ ${chalk7.green("\u27A4")} Authentication Required`));
       }
     };
     const { nextVersion, latestPublishedVersion } = await getNextVersion(targetVersionPrefix, tag);
-    Logger14.info(`Latest published version of akanjs: ${latestPublishedVersion ?? "none"}`);
-    Logger14.info(`Next version of akanjs: ${nextVersion}`);
+    Logger15.info(`Latest published version of akanjs: ${latestPublishedVersion ?? "none"}`);
+    Logger15.info(`Next version of akanjs: ${nextVersion}`);
     for (const library of akanPkgs) {
       const packageJson = await workspace.readJson(`pkgs/${library}/package.json`);
       const newPackageJsonStr = JSON.stringify(this.#normalizeAkanPackageJson(packageJson, library, nextVersion), null, 2);
@@ -11389,20 +11800,20 @@ ${chalk7.green("\u27A4")} Authentication Required`));
         message: "Are you sure you want to deploy the libraries?"
       });
       if (!isDeployConfirmed) {
-        Logger14.error("Deployment cancelled");
+        Logger15.error("Deployment cancelled");
         return;
       }
     }
     await Promise.all(akanPkgs.map(async (library) => {
-      Logger14.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
+      Logger15.info(`Publishing ${library}@${nextVersion} to ${registry ?? "npm"}...`);
       await workspace.spawn("npm", ["publish", "--tag", tag, ...this.#getRegistryArgs(registry), ...this.#getLocalRegistryAuthArgs(registry)], {
-        cwd: path38.join(workspace.workspaceRoot, "dist/pkgs", library),
+        cwd: path39.join(workspace.workspaceRoot, "dist/pkgs", library),
         env: this.#getRegistryEnv(registry),
         stdio: "inherit"
       });
-      Logger14.info(`${library}@${nextVersion} is published to ${registry ?? "npm"}`);
+      Logger15.info(`${library}@${nextVersion} is published to ${registry ?? "npm"}`);
     }));
-    Logger14.info(`All libraries are published to ${registry ?? "npm"}`);
+    Logger15.info(`All libraries are published to ${registry ?? "npm"}`);
   }
   async update(workspace, tag = "latest", { registryUrl } = {}) {
     const registry = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
@@ -11454,7 +11865,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await workspace.remove(localPath);
   }
   async uploadEnv(cloudApi2, workspaceId, filePath) {
-    const file = new File([Bun.file(filePath)], path38.basename(filePath));
+    const file = new File([Bun.file(filePath)], path39.basename(filePath));
     await cloudApi2.uploadEnv(workspaceId, file);
   }
   async downloadEnvByScp(workspace) {
@@ -11465,7 +11876,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await workspace.mkdir("local");
     await workspace.remove(envArchivePath);
     try {
-      Logger14.info(`Downloading env archive from remote server "${remoteServer.name}"...`);
+      Logger15.info(`Downloading env archive from remote server "${remoteServer.name}"...`);
       await workspace.spawn("scp", this.#getScpArgs(remoteServer.config, remoteTarget, envArchivePath), {
         cwd: workspace.workspaceRoot,
         stdio: "inherit"
@@ -11488,7 +11899,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
         cwd: workspace.workspaceRoot,
         stdio: "inherit"
       });
-      Logger14.info(`Uploading env archive to remote server "${remoteServer.name}"...`);
+      Logger15.info(`Uploading env archive to remote server "${remoteServer.name}"...`);
       await workspace.spawn("scp", this.#getScpArgs(remoteServer.config, filePath, remoteTarget), {
         cwd: workspace.workspaceRoot,
         stdio: "inherit"
@@ -11512,7 +11923,7 @@ ${chalk7.green("\u27A4")} Authentication Required`));
     await workspace.spawn("tar", ["-cf", "local/env.tar", ...envFilePaths], {
       cwd: workspace.workspaceRoot
     });
-    Logger14.info(`Archived ${envFilePaths.length} environment files to local/env.tar`);
+    Logger15.info(`Archived ${envFilePaths.length} environment files to local/env.tar`);
     return { files: envFilePaths, path: "local/env.tar" };
   }
 }
@@ -11546,13 +11957,13 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
   async uploadEnv(workspace) {
     const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path: path39 } = await this.cloudRunner.gatherEnvFiles(workspace);
+    const { path: path40 } = await this.cloudRunner.gatherEnvFiles(workspace);
     if (workspaceId) {
       const cloudApi2 = await CloudApi.fromHost(workspace);
-      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path39);
+      await this.cloudRunner.uploadEnv(cloudApi2, workspaceId, path40);
       return;
     }
-    await this.cloudRunner.uploadEnvByScp(workspace, path39);
+    await this.cloudRunner.uploadEnvByScp(workspace, path40);
   }
   async deployAkan(workspace, { test = true, registryUrl } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
@@ -11569,7 +11980,7 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
     const spinner2 = workspace.spinning("Updating Akan.js packages and CLI...");
     await this.cloudRunner.update(workspace, tag, { registryUrl });
     spinner2.succeed("Akan.js packages and CLI updated, global version is below");
-    Logger15.raw("> Akan version: ");
+    Logger16.raw("> Akan version: ");
     await workspace.spawn("akan", ["--version"], { stdio: "inherit" });
   }
 }
@@ -11643,6 +12054,235 @@ class CloudCommand extends command("cloud", [CloudScript], ({ public: target })
 })) {
 }
 
+// pkgs/@akanjs/cli/context/context.script.ts
+import { Logger as Logger17 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/context/context.runner.ts
+var jsonText = (value) => JSON.stringify(value, null, 2);
+var renderDoctorText = (result) => {
+  if (result.diagnostics.length === 0)
+    return `No Akan workspace diagnostics found.
+`;
+  return `${result.diagnostics.map((diagnostic) => [
+    `[${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`,
+    diagnostic.path ? `  ${diagnostic.path}` : ""
+  ].filter(Boolean).join(`
+`)).join(`
+
+`)}
+`;
+};
+var resourceList = [
+  { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/framework", name: "Framework guideline", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/modelSignal", name: "Model signal guideline", mimeType: "text/markdown" },
+  { uri: "akan://workspace/summary", name: "Workspace summary", mimeType: "application/json" },
+  { uri: "akan://workspace/apps", name: "Workspace apps", mimeType: "application/json" },
+  { uri: "akan://workspace/modules", name: "Workspace modules", mimeType: "application/json" }
+];
+
+class ContextRunner extends runner("context") {
+  async getContext(workspace, {
+    format = "markdown",
+    app = null,
+    module = null
+  } = {}) {
+    const context = await AkanContextAnalyzer.analyze(workspace, {
+      app,
+      module,
+      includeAbstractContent: !!module
+    });
+    return format === "json" ? `${jsonText(context)}
+` : AkanContextAnalyzer.renderMarkdown(context, { module });
+  }
+  async doctor(workspace, { format = "text", strict = false } = {}) {
+    const result = await AkanContextAnalyzer.doctor(workspace, { strict });
+    return format === "json" ? `${jsonText(result)}
+` : renderDoctorText(result);
+  }
+  async getGuidelineResource(name) {
+    return await Prompter.getInstruction(name);
+  }
+  async runMcp(workspace) {
+    const decoder = new TextDecoder;
+    let buffer = "";
+    const respond = (id, result) => {
+      const payload = JSON.stringify({ jsonrpc: "2.0", id, result });
+      process.stdout.write(`Content-Length: ${Buffer.byteLength(payload)}\r
+\r
+${payload}`);
+    };
+    const respondError = (id, code, message) => {
+      const payload = JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+      process.stdout.write(`Content-Length: ${Buffer.byteLength(payload)}\r
+\r
+${payload}`);
+    };
+    const readResource = async (uri) => {
+      const context = await AkanContextAnalyzer.analyze(workspace);
+      if (uri === "akan://docs/framework" || uri === "akan://guidelines/framework")
+        return { uri, mimeType: "text/markdown", text: await Prompter.getInstruction("framework") };
+      if (uri === "akan://guidelines/modelSignal")
+        return { uri, mimeType: "text/markdown", text: await Prompter.getInstruction("modelSignal") };
+      if (uri === "akan://workspace/summary")
+        return { uri, mimeType: "application/json", text: jsonText(context) };
+      if (uri === "akan://workspace/apps")
+        return { uri, mimeType: "application/json", text: jsonText(context.apps) };
+      if (uri === "akan://workspace/modules")
+        return { uri, mimeType: "application/json", text: jsonText(AkanContextAnalyzer.findModules(context)) };
+      const abstractMatch = uri.match(/^akan:\/\/workspace\/modules\/(.+)\/abstract$/);
+      if (abstractMatch) {
+        const detailed = await AkanContextAnalyzer.analyze(workspace, {
+          module: abstractMatch[1],
+          includeAbstractContent: true
+        });
+        const abstract = AkanContextAnalyzer.findModules(detailed, abstractMatch[1])[0]?.abstract;
+        return { uri, mimeType: "text/markdown", text: abstract?.content ?? "" };
+      }
+      throw new Error(`Unknown resource: ${uri}`);
+    };
+    const handle = async (request) => {
+      const params = request.params ?? {};
+      if (request.method === "initialize") {
+        respond(request.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {}, resources: {} },
+          serverInfo: { name: "akan", version: process.env.AKAN_VERSION ?? "0.0.0" }
+        });
+      } else if (request.method === "tools/list") {
+        respond(request.id, {
+          tools: [
+            { name: "get_workspace_summary", inputSchema: { type: "object", properties: {} } },
+            { name: "list_apps", inputSchema: { type: "object", properties: {} } },
+            { name: "list_modules", inputSchema: { type: "object", properties: {} } },
+            {
+              name: "get_module_context",
+              inputSchema: { type: "object", properties: { module: { type: "string" } } }
+            },
+            {
+              name: "get_guideline",
+              inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] }
+            },
+            {
+              name: "explain_command",
+              inputSchema: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+            },
+            { name: "doctor_workspace", inputSchema: { type: "object", properties: { strict: { type: "boolean" } } } }
+          ]
+        });
+      } else if (request.method === "tools/call") {
+        const name = params.name;
+        const args = params.arguments ?? {};
+        const context = await AkanContextAnalyzer.analyze(workspace, {
+          module: args.module ?? null,
+          includeAbstractContent: name === "get_module_context"
+        });
+        const result = await (async () => {
+          if (name === "get_workspace_summary")
+            return context;
+          if (name === "list_apps")
+            return context.apps;
+          if (name === "list_modules")
+            return AkanContextAnalyzer.findModules(context);
+          if (name === "get_module_context")
+            return AkanContextAnalyzer.findModules(context, args.module);
+          if (name === "get_guideline")
+            return await Prompter.getInstruction(args.name);
+          if (name === "doctor_workspace")
+            return await AkanContextAnalyzer.doctor(workspace, { strict: !!args.strict });
+          if (name === "explain_command")
+            return this.explainCommand(args.command);
+          throw new Error(`Unknown tool: ${name}`);
+        })();
+        respond(request.id, {
+          content: [{ type: "text", text: typeof result === "string" ? result : jsonText(result) }]
+        });
+      } else if (request.method === "resources/list") {
+        respond(request.id, { resources: resourceList });
+      } else if (request.method === "resources/read") {
+        respond(request.id, { contents: [await readResource(params.uri)] });
+      } else if (!request.method.endsWith("/initialized")) {
+        respondError(request.id, -32601, `Unknown method: ${request.method}`);
+      }
+    };
+    const parse = async () => {
+      while (true) {
+        const headerEnd = buffer.indexOf(`\r
+\r
+`);
+        if (headerEnd < 0)
+          return;
+        const header = buffer.slice(0, headerEnd);
+        const match = /Content-Length:\s*(\d+)/i.exec(header);
+        if (!match) {
+          buffer = buffer.slice(headerEnd + 4);
+          continue;
+        }
+        const length = Number(match[1]);
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = bodyStart + length;
+        if (buffer.length < bodyEnd)
+          return;
+        const body = buffer.slice(bodyStart, bodyEnd);
+        buffer = buffer.slice(bodyEnd);
+        await handle(JSON.parse(body));
+      }
+    };
+    for await (const chunk of Bun.stdin.stream()) {
+      buffer += decoder.decode(chunk);
+      await parse();
+    }
+  }
+  explainCommand(command3) {
+    const explanations = {
+      context: "`akan context` prints agent-readable workspace, app, module, and abstract metadata.",
+      doctor: "`akan doctor` reports workspace convention diagnostics. Use `--format json` for agents.",
+      "guideline show": "`akan guideline show <name>` prints an Akan codegen guideline instruction.",
+      agent: "`akan agent install <target>` writes editor-specific agent rules with overwrite protection.",
+      mcp: "`akan mcp` starts the read-only Akan MCP server over stdio."
+    };
+    return explanations[command3] ?? `No detailed explanation is available for ${command3}. Run \`akan --help\` for command help.`;
+  }
+}
+
+// pkgs/@akanjs/cli/context/context.script.ts
+class ContextScript extends script("context", [ContextRunner]) {
+  async context(workspace, options = {}) {
+    Logger17.rawLog(await this.contextRunner.getContext(workspace, options));
+  }
+  async doctor(workspace, options = {}) {
+    Logger17.rawLog(await this.contextRunner.doctor(workspace, options));
+  }
+  async mcp(workspace) {
+    await this.contextRunner.runMcp(workspace);
+  }
+}
+
+// pkgs/@akanjs/cli/context/context.command.ts
+class ContextCommand extends command("context", [ContextScript], ({ public: target }) => ({
+  context: target({ desc: "Print agent-readable Akan workspace context" }).option("format", String, {
+    desc: "output format",
+    default: "markdown",
+    enum: ["markdown", "json"]
+  }).option("app", String, { desc: "app name to include", nullable: true }).option("module", String, { desc: "module name to include with abstract content", nullable: true }).with(Workspace).exec(async function(format, app, module, workspace) {
+    await this.contextScript.context(workspace, { format, app, module });
+  }),
+  doctor: target({ desc: "Report Akan workspace convention diagnostics" }).option("format", String, {
+    desc: "output format",
+    default: "text",
+    enum: ["text", "json"]
+  }).option("strict", Boolean, { desc: "treat recommended conventions as errors", default: false }).with(Workspace).exec(async function(format, strict, workspace) {
+    await this.contextScript.doctor(workspace, { format, strict });
+  }),
+  mcp: target({ desc: "Start the read-only Akan MCP server over stdio" }).with(Workspace).exec(async function(workspace) {
+    await this.contextScript.mcp(workspace);
+  })
+})) {
+}
+
+// pkgs/@akanjs/cli/guideline/guideline.script.ts
+import { Logger as Logger18 } from "akanjs/common";
+
 // pkgs/@akanjs/cli/guideline/guideline.prompt.ts
 import { randomPicks } from "akanjs/common";
 
@@ -11664,14 +12304,14 @@ class GuidelinePrompt extends Prompter {
   async#getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const glob = new Bun.Glob(matchPattern);
     const paths = [];
-    for await (const path39 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
-      if (avoidDirs.some((dir) => path39.includes(dir)))
+    for await (const path40 of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path40.includes(dir)))
         continue;
-      const fileContent = await FileSys.readText(path39);
+      const fileContent = await FileSys.readText(path40);
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path39);
+      paths.push(path40);
     }
     return paths;
   }
@@ -11906,6 +12546,22 @@ class GuidelineRunner extends runner("guideline") {
 
 // pkgs/@akanjs/cli/guideline/guideline.script.ts
 class GuidelineScript extends script("guideline", [GuidelineRunner]) {
+  async guideline(action, name = null, format = "markdown") {
+    if (action === "list") {
+      const guidelines = await Prompter.listGuidelines();
+      Logger18.rawLog(format === "json" ? JSON.stringify({ guidelines }, null, 2) : guidelines.join(`
+`));
+      return;
+    }
+    if (action === "show") {
+      if (!name)
+        throw new Error("Guideline name is required. Example: akan guideline show framework");
+      const [instruction, guideJson] = await Promise.all([Prompter.getInstruction(name), Prompter.getGuideJson(name)]);
+      Logger18.rawLog(format === "json" ? JSON.stringify({ name, instruction, guideJson }, null, 2) : instruction);
+      return;
+    }
+    throw new Error(`Unknown guideline action: ${action}. Use "list" or "show".`);
+  }
   async generateInstruction(workspace, name = null) {
     const guideName = name ?? await Prompter.selectGuideline();
     await this.guidelineRunner.generateInstruction(workspace, guideName);
@@ -11934,6 +12590,13 @@ class GuidelineScript extends script("guideline", [GuidelineRunner]) {
 
 // pkgs/@akanjs/cli/guideline/guideline.command.ts
 class GuidelineCommand extends command("guideline", [GuidelineScript], ({ public: target }) => ({
+  guideline: target({ desc: "List or show Akan AI guideline instructions" }).arg("action", String, { desc: "list or show" }).arg("name", String, { desc: "guideline name for show", nullable: true }).option("format", String, {
+    desc: "output format",
+    default: "markdown",
+    enum: ["markdown", "json"]
+  }).exec(async function(action, name, format) {
+    await this.guidelineScript.guideline(action, name, format);
+  }),
   generateInstruction: target({ devOnly: true, desc: "Generate AI development guideline/instruction for your project" }).arg("name", String, { ask: "name of the instruction", nullable: true }).with(Workspace).exec(async function(name, workspace) {
     await this.guidelineScript.generateInstruction(workspace, name);
   }),
@@ -11968,8 +12631,8 @@ class LibraryCommand extends command("library", [LibraryScript], ({ public: targ
 
 // pkgs/@akanjs/cli/localRegistry/localRegistry.runner.ts
 import { mkdir as mkdir11, rm as rm5 } from "fs/promises";
-import path39 from "path";
-import { Logger as Logger16 } from "akanjs/common";
+import path40 from "path";
+import { Logger as Logger19 } from "akanjs/common";
 var defaultLocalRegistryUrl = "http://127.0.0.1:4873";
 var containerName = "akan-verdaccio";
 var smokeRepoName = "akan-local-smoke";
@@ -11983,11 +12646,11 @@ class LocalRegistryRunner extends runner("localRegistry") {
     const registry = this.getRegistryUrl(registryUrl);
     try {
       await workspace.spawn("docker", ["inspect", containerName]);
-      Logger16.info(`Local registry is already running at ${registry}`);
+      Logger19.info(`Local registry is already running at ${registry}`);
       return registry;
     } catch {}
-    const configPath2 = path39.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
-    const storagePath = path39.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
+    const configPath2 = path40.join(workspace.workspaceRoot, "pkgs/@akanjs/cli/localRegistry/verdaccio.yaml");
+    const storagePath = path40.join(workspace.workspaceRoot, ".akan/verdaccio/storage");
     await mkdir11(storagePath, { recursive: true });
     await workspace.spawn("docker", [
       "run",
@@ -12003,20 +12666,20 @@ class LocalRegistryRunner extends runner("localRegistry") {
       `${storagePath}:/verdaccio/storage`,
       "verdaccio/verdaccio:6"
     ], { stdio: "inherit" });
-    Logger16.info(`Local registry is running at ${registry}`);
+    Logger19.info(`Local registry is running at ${registry}`);
     return registry;
   }
   async reset(workspace) {
     try {
       await workspace.spawn("docker", ["rm", "-f", containerName], { stdio: "inherit" });
     } catch {}
-    await rm5(path39.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
-    Logger16.info("Local registry storage has been reset");
+    await rm5(path40.join(workspace.workspaceRoot, ".akan/verdaccio"), { recursive: true, force: true });
+    Logger19.info("Local registry storage has been reset");
   }
   async smoke(workspace, { registryUrl } = {}) {
     const registry = this.getRegistryUrl(registryUrl);
-    const smokeRoot = path39.join(workspace.workspaceRoot, ".akan/e2e");
-    await rm5(path39.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
+    const smokeRoot = path40.join(workspace.workspaceRoot, ".akan/e2e");
+    await rm5(path40.join(smokeRoot, smokeRepoName), { recursive: true, force: true });
     await workspace.spawn(process.execPath, [
       "dist/pkgs/create-akan-workspace/index.js",
       smokeRepoName,
@@ -12033,11 +12696,11 @@ class LocalRegistryRunner extends runner("localRegistry") {
       stdio: "inherit"
     });
     await workspace.spawn("akan", ["build", smokeAppName], {
-      cwd: path39.join(smokeRoot, smokeRepoName),
+      cwd: path40.join(smokeRoot, smokeRepoName),
       env: { ...process.env, AKAN_NPM_REGISTRY: registry, NPM_CONFIG_REGISTRY: registry },
       stdio: "inherit"
     });
-    Logger16.info(`Local registry smoke test completed for ${smokeRepoName}/${smokeAppName}`);
+    Logger19.info(`Local registry smoke test completed for ${smokeRepoName}/${smokeAppName}`);
   }
 }
 
@@ -12112,7 +12775,7 @@ import { lowerlize } from "akanjs/common";
 
 // pkgs/@akanjs/cli/module/module.script.ts
 import { input as input6 } from "@inquirer/prompts";
-import { capitalize as capitalize6, randomPicks as randomPicks2 } from "akanjs/common";
+import { capitalize as capitalize7, randomPicks as randomPicks2 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/page/page.runner.ts
 class PageRunner extends runner("page") {
@@ -12142,7 +12805,7 @@ function pluralizeName(name) {
 }
 
 // pkgs/@akanjs/cli/module/module.request.ts
-import { capitalize as capitalize4 } from "akanjs/common";
+import { capitalize as capitalize5 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/module/module.prompt.ts
 var componentDefaultDescription = ({
@@ -12267,7 +12930,7 @@ var requestTemplate = ({
 		${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize4(modelName),
+  ModelName: ModelName ?? capitalize5(modelName),
   exampleFiles,
   constant,
   properties
@@ -12324,7 +12987,7 @@ var requestView = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize4(modelName),
+  ModelName: ModelName ?? capitalize5(modelName),
   exampleFiles,
   constant,
   properties
@@ -12385,7 +13048,7 @@ var requestUnit = ({
 	 ${componentDefaultDescription({
   sysName,
   modelName,
-  ModelName: ModelName ?? capitalize4(modelName),
+  ModelName: ModelName ?? capitalize5(modelName),
   exampleFiles,
   constant,
   properties
@@ -12434,7 +13097,7 @@ var requestUnit = ({
 	`;
 
 // pkgs/@akanjs/cli/module/module.runner.ts
-import { capitalize as capitalize5 } from "akanjs/common";
+import { capitalize as capitalize6 } from "akanjs/common";
 class ModuleRunner extends runner("module") {
   async createService(module) {
     const serviceName = module.name.replace(/^_+/, "");
@@ -12443,13 +13106,15 @@ class ModuleRunner extends runner("module") {
       template: "service",
       dict: { model: serviceName, sysName: module.sys.name }
     });
-    const [dictionaryContent, serviceContent, signalContent, storeContent] = await Promise.all([
+    const [abstractContent, dictionaryContent, serviceContent, signalContent, storeContent] = await Promise.all([
+      module.readFile(`${serviceName}.abstract.md`),
       module.readFile(`${serviceName}.dictionary.ts`),
       module.readFile(`${serviceName}.service.ts`),
       module.readFile(`${serviceName}.signal.ts`),
       module.readFile(`${serviceName}.store.ts`)
     ]);
     return {
+      abstract: { filename: `${serviceName}.abstract.md`, content: abstractContent },
       dictionary: { filename: `${serviceName}.dictionary.ts`, content: dictionaryContent },
       service: { filename: `${serviceName}.service.ts`, content: serviceContent },
       signal: { filename: `${serviceName}.signal.ts`, content: signalContent },
@@ -12462,13 +13127,13 @@ class ModuleRunner extends runner("module") {
   async createComponentTemplate(module, type) {
     await module.sys.applyTemplate({
       basePath: `./lib/${module.name}`,
-      template: `module/__Model__.${capitalize5(type)}.tsx`,
+      template: `module/__Model__.${capitalize6(type)}.tsx`,
       dict: { model: module.name, appName: module.sys.name }
     });
     return {
       component: {
-        filename: `${module.name}.${capitalize5(type)}.tsx`,
-        content: await module.sys.readFile(`lib/${module.name}/${capitalize5(module.name)}.${capitalize5(type)}.tsx`)
+        filename: `${module.name}.${capitalize6(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize6(module.name)}.${capitalize6(type)}.tsx`)
       }
     };
   }
@@ -12480,6 +13145,7 @@ class ModuleRunner extends runner("module") {
       dict: { model: module.name, models: names, sysName: module.sys.name }
     });
     const [
+      abstractContent,
       constantContent,
       dictionaryContent,
       serviceContent,
@@ -12491,6 +13157,7 @@ class ModuleRunner extends runner("module") {
       zoneContent,
       utilContent
     ] = await Promise.all([
+      module.readFile(`${module.name}.abstract.md`),
       module.readFile(`${module.name}.constant.ts`),
       module.readFile(`${module.name}.dictionary.ts`),
       module.readFile(`${module.name}.service.ts`),
@@ -12503,6 +13170,7 @@ class ModuleRunner extends runner("module") {
       module.readFile(`${module.name}.Util.tsx`)
     ]);
     return {
+      abstract: { filename: `${module.name}.abstract.md`, content: abstractContent },
       constant: { filename: `${module.name}.constant.ts`, content: constantContent },
       dictionary: { filename: `${module.name}.dictionary.ts`, content: dictionaryContent },
       service: { filename: `${module.name}.service.ts`, content: serviceContent },
@@ -12591,7 +13259,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   async createTemplate(mod) {
     const { component: template } = await this.moduleRunner.createComponentTemplate(mod, "template");
     const templateExampleFiles = (await mod.sys.getTemplatesSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Template.tsx`));
-    const Name = capitalize6(mod.name);
+    const Name = capitalize7(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createTemplate", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -12610,7 +13278,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   }
   async createUnit(mod) {
     const { component: unit } = await this.moduleRunner.createComponentTemplate(mod, "unit");
-    const Name = capitalize6(mod.name);
+    const Name = capitalize7(mod.name);
     const unitExampleFiles = (await mod.sys.getUnitsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.Unit.tsx`));
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
@@ -12631,7 +13299,7 @@ class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
   async createView(mod) {
     const { component: view } = await this.moduleRunner.createComponentTemplate(mod, "view");
     const viewExampleFiles = (await mod.sys.getViewsSourceCode()).filter((f) => !f.filePath.includes(`${mod.name}.View.tsx`));
-    const Name = capitalize6(mod.name);
+    const Name = capitalize7(mod.name);
     const relatedCnsts = getRelatedCnsts(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const constant = await FileSys.readText(`${mod.sys.cwdPath}/lib/${mod.name}/${mod.name}.constant.ts`);
     const session = new AiSession("createView", { workspace: mod.sys.workspace, cacheKey: mod.name });
@@ -12902,11 +13570,11 @@ class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target
 }
 
 // pkgs/@akanjs/cli/workspace/workspace.script.ts
-import path41 from "path";
-import { Logger as Logger17 } from "akanjs/common";
+import path42 from "path";
+import { Logger as Logger20 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/workspace/workspace.runner.ts
-import path40 from "path";
+import path41 from "path";
 var defaultWorkspacePeerDependencies = new Set([
   "@react-spring/web",
   "@use-gesture/react",
@@ -12925,6 +13593,30 @@ var defaultWorkspacePeerDependencies = new Set([
 ]);
 
 class WorkspaceRunner extends runner("workspace") {
+  async generateAgentRules(workspace, { overwrite = false, cursorRules = true } = {}) {
+    const [appNames] = await workspace.getExecs();
+    const dict = {
+      repoName: workspace.repoName,
+      appName: appNames[0] ?? "app"
+    };
+    const created = await workspace.applyTemplate({
+      basePath: ".",
+      template: "workspaceRoot/AGENTS.md.template",
+      dict,
+      overwrite
+    });
+    if (!cursorRules)
+      return created;
+    return [
+      ...created,
+      ...await workspace.applyTemplate({
+        basePath: ".cursor/rules",
+        template: "workspaceRoot/.cursor/rules/akan.mdc.template",
+        dict,
+        overwrite
+      })
+    ];
+  }
   async createWorkspace(repoName, appName, {
     dirname: dirname2 = ".",
     init = true,
@@ -12932,7 +13624,7 @@ class WorkspaceRunner extends runner("workspace") {
     registryUrl
   }) {
     const cwdPath = process.cwd();
-    const workspaceRoot = path40.join(cwdPath, dirname2, repoName);
+    const workspaceRoot = path41.join(cwdPath, dirname2, repoName);
     const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
     const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname2}/${repoName}...`);
@@ -12988,9 +13680,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getCliPackageJson() {
     const packageJsonCandidates = [
-      path40.join(import.meta.dir, "../package.json"),
-      path40.join(import.meta.dir, "package.json"),
-      path40.join(path40.dirname(Bun.main), "package.json")
+      path41.join(import.meta.dir, "../package.json"),
+      path41.join(import.meta.dir, "package.json"),
+      path41.join(path41.dirname(Bun.main), "package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
@@ -13006,9 +13698,9 @@ class WorkspaceRunner extends runner("workspace") {
   }
   async#getAkanPackageJson() {
     const packageJsonCandidates = [
-      path40.join(import.meta.dir, "../../../akanjs/package.json"),
-      path40.join(process.cwd(), "pkgs/akanjs/package.json"),
-      path40.join(path40.dirname(Bun.main), "node_modules/akanjs/package.json")
+      path41.join(import.meta.dir, "../../../akanjs/package.json"),
+      path41.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path41.join(path41.dirname(Bun.main), "node_modules/akanjs/package.json")
     ];
     try {
       packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
@@ -13022,13 +13714,13 @@ class WorkspaceRunner extends runner("workspace") {
     }
     let current = import.meta.dir;
     for (let depth = 0;depth < 6; depth++) {
-      const packageJsonPath = path40.join(current, "package.json");
+      const packageJsonPath = path41.join(current, "package.json");
       if (await Bun.file(packageJsonPath).exists()) {
         const packageJson = await FileSys.readJson(packageJsonPath);
         if (packageJson.name === "akanjs")
           return packageJson;
       }
-      const parent = path40.dirname(current);
+      const parent = path41.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -13077,13 +13769,18 @@ class WorkspaceScript extends script("workspace", [
     } catch (_) {
       gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
     }
-    const workspacePath = path41.join(dirname2, repoName);
-    Logger17.rawLog(`
+    const workspacePath = path42.join(dirname2, repoName);
+    Logger20.rawLog(`
 \uD83C\uDF89 Welcome aboard! Workspace created in ${dirname2}/${repoName}`);
-    Logger17.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
-    Logger17.rawLog(`
+    Logger20.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
+    Logger20.rawLog(`
 \uD83D\uDC4B Happy coding!`);
   }
+  async generateAgentRules(workspace, { overwrite = false, cursorRules = true } = {}) {
+    const spinner2 = workspace.spinning("Generating agent rules...");
+    const files = await this.workspaceRunner.generateAgentRules(workspace, { overwrite, cursorRules });
+    spinner2.succeed(`Agent rules ready (${files.length} file${files.length === 1 ? "" : "s"})`);
+  }
   async lint(exec2, workspace, { fix = true } = {}) {
     if (exec2 instanceof AppExecutor)
       await this.applicationScript.sync(exec2);
@@ -13143,6 +13840,9 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
     const appName = app || "app";
     await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), { dirname: dir, installLibs: libs, init, ...registry ? { registryUrl: registry } : {} });
   }),
+  generateAgentRules: target({ desc: "Generate AGENTS.md and optional Cursor rules for Akan coding agents" }).option("overwrite", Boolean, { desc: "Overwrite existing agent rule files", default: false }).option("cursorRules", Boolean, { desc: "Generate .cursor/rules/akan.mdc", default: true }).with(Workspace).exec(async function(overwrite, cursorRules, workspace) {
+    await this.workspaceScript.generateAgentRules(workspace, { overwrite, cursorRules });
+  }),
   lint: target({ desc: "Lint and fix code in a specific app/lib/pkg" }).with(Exec).option("fix", Boolean, { default: true }).with(Workspace).exec(async function(exec2, fix, workspace) {
     await this.workspaceScript.lint(exec2, workspace, { fix });
   }),
@@ -13156,4 +13856,4 @@ class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public
 }
 
 // pkgs/@akanjs/cli/index.ts
-runCommands(WorkspaceCommand, ApplicationCommand, LibraryCommand, LocalRegistryCommand, PackageCommand, ModuleCommand, PageCommand, CloudCommand, GuidelineCommand, ScalarCommand);
+runCommands(WorkspaceCommand, AgentCommand, ApplicationCommand, LibraryCommand, LocalRegistryCommand, PackageCommand, ModuleCommand, PageCommand, ContextCommand, CloudCommand, GuidelineCommand, ScalarCommand);