@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/{index-2tv3fdx4.js → index-3w94e7n3.js}

@@ -1,161 +1,474 @@
 // @bun
 import {
-  FileSys
-} from "./index-q0y2jq9j.js";
-import {
-  getDirname2
-} from "./index-6wwzs1bc.js";
+  getDirname2,
+  FileSys2
+} from "./index-52w0fvh8.js";
 
-// pkgs/@akanjs/devkit/codegenLock.ts
-import { mkdir, open, readFile, rm, stat } from "fs/promises";
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+import { readdir, rm } from "fs/promises";
+import path2 from "path";
+
+// pkgs/@akanjs/devkit/transforms/asyncDefaultExportDetector.ts
+import fs from "fs";
 import path from "path";
-import { Logger } from "akanjs/common";
 
-class CodegenLock {
-  static fileName = "codegen.lock";
-  static waitTimeoutMs = 1e4;
-  static unknownHolderStaleMs = 60000;
-  static #pollMs = 25;
-  static #logger = new Logger("CodegenLock");
-  static #queue = Promise.resolve();
-  static pathIn(workspaceRoot) {
-    return path.join(workspaceRoot, "local", ".akan", CodegenLock.fileName);
-  }
-  static async run(workspaceRoot, label, fn) {
-    const ahead = CodegenLock.#queue;
-    let done;
-    CodegenLock.#queue = new Promise((resolve) => {
-      done = resolve;
-    });
-    try {
-      await CodegenLock.#waitForQueue(ahead, label);
-      return await CodegenLock.#withFileLock(workspaceRoot, label, fn);
-    } finally {
-      done();
-    }
+class AsyncDefaultExportDetector {
+  static #typescriptLoad;
+  static #loadTypescript() {
+    AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then((mod) => mod.default ?? mod);
+    return AsyncDefaultExportDetector.#typescriptLoad;
   }
-  static async#waitForQueue(ahead, label) {
-    let timer = null;
-    const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("expired"), CodegenLock.waitTimeoutMs);
-    });
+  static async detect(moduleAbsPath) {
     try {
-      if (await Promise.race([ahead.then(() => "done"), expired]) === "expired")
-        CodegenLock.#logger.warn(`codegen lock queued past ${CodegenLock.waitTimeoutMs}ms in this process; continuing without waiting (${label})`);
-    } finally {
-      if (timer)
-        clearTimeout(timer);
+      const typescript = await AsyncDefaultExportDetector.#loadTypescript();
+      const source = fs.readFileSync(path.resolve(moduleAbsPath), "utf8");
+      const sourceFile = typescript.createSourceFile(moduleAbsPath, source, typescript.ScriptTarget.Latest, true, /\.[tj]sx$/.test(moduleAbsPath) ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS);
+      return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
+    } catch {
+      return false;
     }
   }
-  static async#withFileLock(workspaceRoot, label, fn) {
-    const lockPath = CodegenLock.pathIn(workspaceRoot);
-    await mkdir(path.dirname(lockPath), { recursive: true }).catch(() => {
-      return;
-    });
-    const held = await CodegenLock.#acquire(lockPath, label);
-    try {
-      return await fn();
-    } finally {
-      if (held)
-        await rm(lockPath, { force: true }).catch(() => {
-          return;
-        });
-    }
+  #ts;
+  constructor(typescript) {
+    this.#ts = typescript;
   }
-  static async#acquire(lockPath, label) {
-    const deadline = Date.now() + CodegenLock.waitTimeoutMs;
-    for (;; ) {
-      const handle = await open(lockPath, "wx").catch(() => null);
-      if (handle) {
-        await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), label })).catch(() => {
-          return;
-        });
-        await handle.close().catch(() => {
-          return;
-        });
-        return true;
+  detectInSourceFile(sourceFile) {
+    const ts = this.#ts;
+    const asyncBindings = new Map;
+    let defaultIdentifier = null;
+    for (const statement of sourceFile.statements) {
+      if (ts.isFunctionDeclaration(statement)) {
+        if (this.#hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+          return this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword);
+        }
+        if (statement.name) {
+          asyncBindings.set(statement.name.text, this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword));
+        }
+        continue;
       }
-      if (await CodegenLock.#reclaimIfAbandoned(lockPath))
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts.isIdentifier(declaration.name))
+            continue;
+          asyncBindings.set(declaration.name.text, this.#isAsyncFunctionExpression(declaration.initializer));
+        }
         continue;
-      if (Date.now() >= deadline) {
-        CodegenLock.#logger.warn(`codegen lock at ${lockPath} held past ${CodegenLock.waitTimeoutMs}ms; continuing without it (${label})`);
-        return false;
       }
-      await Bun.sleep(CodegenLock.#pollMs);
+      if (ts.isExportAssignment(statement)) {
+        if (this.#isAsyncFunctionExpression(statement.expression))
+          return true;
+        if (ts.isCallExpression(statement.expression))
+          return true;
+        if (ts.isIdentifier(statement.expression))
+          defaultIdentifier = statement.expression.text;
+        continue;
+      }
+      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const specifier of statement.exportClause.elements) {
+          if (specifier.name.text !== "default")
+            continue;
+          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
+        }
+      }
     }
+    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
   }
-  static async#reclaimIfAbandoned(lockPath) {
-    const info = await stat(lockPath).catch(() => null);
-    if (!info)
-      return true;
-    const holder = CodegenLock.#parseHolder(await readFile(lockPath, "utf8").catch(() => ""));
-    if (holder) {
-      if (CodegenLock.#isAlive(holder.pid))
-        return false;
-    } else if (Date.now() - info.mtimeMs < CodegenLock.unknownHolderStaleMs)
-      return false;
-    await rm(lockPath, { force: true }).catch(() => {
-      return;
-    });
-    return true;
-  }
-  static #parseHolder(raw) {
-    try {
-      const parsed = JSON.parse(raw);
-      if (typeof parsed.pid !== "number" || typeof parsed.at !== "number")
-        return null;
-      return { pid: parsed.pid, at: parsed.at, label: typeof parsed.label === "string" ? parsed.label : "" };
-    } catch {
-      return null;
-    }
+  #hasModifier(node, kind) {
+    const ts = this.#ts;
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
   }
-  static #isAlive(pid) {
-    if (!Number.isInteger(pid) || pid <= 0)
-      return false;
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch (error) {
-      return error.code === "EPERM";
-    }
+  #isAsyncFunctionExpression(node) {
+    const ts = this.#ts;
+    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
   }
 }
 
-// pkgs/@akanjs/devkit/spinner.ts
-import ora from "ora";
+// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
+var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
+var IMPLICIT_LAYOUT_DIR = path2.join(".akan", "generated", "root-layouts");
+var IMPLICIT_DICT_DIR = path2.join(".akan", "generated", "dict");
+var IMPLICIT_OVERRIDES_DIR = path2.join(".akan", "generated", "overrides");
+var OVERRIDES_KEY_RE = /^\.\/(.+\/)?_overrides\.(tsx|ts|jsx|js)$/;
+var importSpecifier = (fromAbsPath, toAbsPath) => {
+  const rel = path2.relative(path2.dirname(fromAbsPath), toAbsPath).split(path2.sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+};
+async function writeGeneratedOverridesLayoutFile(opts) {
+  const filename = `${opts.key.replace(/^\.\//, "").replace(/[^a-zA-Z0-9]+/g, "_")}.tsx`;
+  const absPath = path2.join(path2.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
+  const source = `"use client";
+import { UiOverrideProvider } from "akanjs/ui";
+import { createElement, type ReactNode } from "react";
+import value from ${JSON.stringify(importSpecifier(absPath, opts.userAbsPath))};
 
-class Spinner {
-  static padding = 12;
-  static oraOptions = { discardStdin: false };
-  static canAnimate(stream = process.stderr) {
-    return !stream.isTTY || stream.columns > 0;
+export default function AkanUiOverridesLayout({ children }: { children?: ReactNode }) {
+  return createElement(UiOverrideProvider, { value }, children);
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function pruneGeneratedFiles(dirAbsPath, keepAbsPaths) {
+  const keep = new Set(keepAbsPaths);
+  const names = await readdir(dirAbsPath).catch(() => []);
+  await Promise.all(names.map((name) => path2.join(dirAbsPath, name)).filter((absPath) => !keep.has(absPath)).map((absPath) => rm(absPath, { force: true })));
+}
+function getRootBoundarySegments(key) {
+  const match = LAYOUT_KEY_RE.exec(key);
+  if (!match)
+    return null;
+  const prefix = match[1]?.replace(/\/$/, "");
+  if (!prefix)
+    return [];
+  return prefix.split("/").filter(Boolean);
+}
+function implicitRootLayoutKey(segments) {
+  return `./${[...segments, "__root_layout"].join("/")}.tsx`;
+}
+function implicitRootLayoutAbsPath(appCwdPath, segments) {
+  const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
+  return path2.join(path2.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
+}
+function isRootBoundarySegments(segments, basePaths) {
+  const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
+  if (firstVisibleIndex === -1)
+    return segments.length <= 1;
+  if (segments.slice(firstVisibleIndex + 1).some((segment) => /^\(.+\)$/.test(segment)))
+    return false;
+  const visible = segments.slice(firstVisibleIndex);
+  const allowedBasePaths = new Set([...basePaths].map((basePath) => basePath.trim()).filter(Boolean));
+  return visible.length === 1 && (firstVisibleIndex > 0 || allowedBasePaths.has(visible[0] ?? ""));
+}
+function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
+  const boundaries = new Map;
+  for (const key of pageKeys) {
+    const segments = getRootBoundarySegments(key);
+    if (!segments)
+      continue;
+    if (!isRootBoundarySegments(segments, basePaths))
+      continue;
+    const id = segments.join("/");
+    boundaries.set(id, {
+      sourceKey: key,
+      sourceAbsPath: path2.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
+      segments
+    });
   }
-  spinner;
-  stopWatch = null;
-  startAt = new Date;
-  prefix;
-  message;
-  enableSpin;
-  constructor(message, { prefix = "", indent = 0, enableSpin = true } = {}) {
-    Spinner.padding = Math.max(Spinner.padding, prefix.length);
-    this.prefix = prefix;
-    this.message = message;
-    this.spinner = ora({ ...Spinner.oraOptions, text: message });
-    this.spinner.prefixText = prefix.padStart(Spinner.padding, " ");
-    this.spinner.indent = indent;
-    this.enableSpin = enableSpin && Spinner.canAnimate();
+  if (boundaries.size === 0)
+    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
+  return [...boundaries.values()].sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
+}
+function hasAncestorRootBoundary(boundary, boundaries) {
+  return boundaries.some((candidate) => candidate !== boundary && candidate.segments.length < boundary.segments.length && candidate.segments.every((segment, index) => boundary.segments[index] === segment));
+}
+function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
+  const rootLayoutKey = pageKeys.find((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && segments.length === 0;
+  });
+  return rootLayoutKey ? path2.resolve(appCwdPath, "page", rootLayoutKey.replace(/^\.\//, "")) : null;
+}
+async function assertEnvClientConvention(appCwdPath, appName) {
+  const envPath = path2.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`);
   }
-  start() {
-    this.startAt = new Date;
-    if (this.enableSpin) {
-      this.spinner.start();
-      this.stopWatch = setInterval(() => {
-        this.spinner.prefixText = this.prefix.padStart(Spinner.padding, " ");
-        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr({ floor: true })})`;
-      }, 1000);
-    } else
-      this.spinner.info();
-    return this;
+}
+async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
+  const absPath = path2.join(path2.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
+  await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
+
+export const allDictionary = getAllDictionary();
+`);
+  return absPath;
+}
+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);
+  const dictMacroSpecifier = dictMacroAbsPath ? importSpecifier(absPath, dictMacroAbsPath) : null;
+  const sourceSpecifier = opts.boundary.sourceAbsPath ? importSpecifier(absPath, opts.boundary.sourceAbsPath) : null;
+  const inheritedSourceAbsPath = opts.rootSourceAbsPath && opts.rootSourceAbsPath !== opts.boundary.sourceAbsPath ? opts.rootSourceAbsPath : null;
+  const inheritedSourceSpecifier = inheritedSourceAbsPath ? importSpecifier(absPath, inheritedSourceAbsPath) : null;
+  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
+void st;
+` : `import "@apps/${opts.appName}/client";
+`;
+  const inheritedLabel = inheritedSourceAbsPath ? path2.relative(opts.appCwdPath, inheritedSourceAbsPath) : "";
+  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedModule from ${JSON.stringify(inheritedSourceSpecifier)};
+const inheritedLayout = resolveRouteModule(inheritedModule as never, ${JSON.stringify(inheritedLabel)}).module as LayoutModule;
+` : `const inheritedLayout: LayoutModule = {};
+`;
+  const prefix = opts.boundary.segments.find((segment) => !/^\(.+\)$/.test(segment)) ?? null;
+  const userLabel = opts.boundary.sourceAbsPath ? path2.relative(opts.appCwdPath, opts.boundary.sourceAbsPath) : "";
+  const userImport = sourceSpecifier ? `import * as userModule from ${JSON.stringify(sourceSpecifier)};
+const userLayout = resolveRouteModule(userModule as never, ${JSON.stringify(userLabel)}).module as LayoutModule;
+const UserLayout = userLayout.default as (props: LayoutProps) => ReactNode | Promise<ReactNode>;
+` : `const UserLayout = ({ children }: LayoutProps) => children;
+const userLayout: LayoutModule = {};
+`;
+  const isAsyncUserLayout = opts.boundary.sourceAbsPath ? await AsyncDefaultExportDetector.detect(opts.boundary.sourceAbsPath) : false;
+  const userLayoutElement = "<UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>";
+  const layoutSignature = isAsyncUserLayout ? "export default async function GeneratedLayout" : "export default function GeneratedLayout";
+  const layoutBinding = isAsyncUserLayout ? `  const layout =
+    process.env.AKAN_PUBLIC_RENDER_ENV === "csr"
+      ? await UserLayout({ params, searchParams, children })
+      : ${userLayoutElement};
+` : "";
+  const layoutChild = isAsyncUserLayout ? "{layout}" : userLayoutElement;
+  const layoutReturn = isAsyncUserLayout ? "layout" : userLayoutElement;
+  const layoutExports = `export async function generateHead(props: PageProps) {
+  if (userLayout.generateHead) return userLayout.generateHead(props);
+  if (userLayout.head !== undefined) return userLayout.head;
+  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
+  return inheritedLayout.head;
+}
+
+export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
+export const Error = userLayout.Error ?? inheritedLayout.Error;
+export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
+
+${layoutSignature}({ children, params, searchParams }: LayoutProps) {
+${layoutBinding}  return `;
+  const source = opts.includeSystemProvider ? `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { loadFonts, resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
+import { System } from "akanjs/ui";
+import { env } from "@apps/${opts.appName}/env/env.client";
+import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
+${clientImport}${inheritedImport}${userImport}
+const userFonts = userLayout.fonts ?? inheritedLayout.fonts ?? [];
+const defaultFonts = userFonts.filter((font) => font.default);
+if (defaultFonts.length > 1) throw new Error("[route-convention] only one default font is allowed per root layout");
+const defaultFont = defaultFonts[0];
+const defaultFontClassName = defaultFont ? (defaultFont.className ?? \`font-\${defaultFont.name}\`) : undefined;
+
+${layoutExports}(
+    <System.Provider
+      of={GeneratedLayout as never}
+      appName=${JSON.stringify(opts.appName)}
+      ${prefix ? `prefix=${JSON.stringify(prefix)}
+      ` : ""}params={params}
+      manifest={userLayout.manifest ?? inheritedLayout.manifest}
+      env={env}
+      theme={userLayout.theme ?? inheritedLayout.theme}
+      fonts={loadFonts(userFonts)}
+      className={defaultFontClassName}
+      layoutStyle={userLayout.layoutStyle ?? inheritedLayout.layoutStyle}
+      reconnect={userLayout.reconnect ?? inheritedLayout.reconnect ?? false}
+      wsConnect={userLayout.wsConnect ?? inheritedLayout.wsConnect ?? true}
+      allDictionary={process.env.AKAN_PUBLIC_RENDER_ENV === "ssr" ? allDictionary : undefined}
+    >
+      ${layoutChild}
+    </System.Provider>
+  );
+}
+` : `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
+import { resolveRouteModule } from "akanjs/client";
+import type { ReactNode } from "react";
+${inheritedImport}${userImport}
+${layoutExports}${layoutReturn};
+}
+`;
+  await Bun.write(absPath, source);
+  return absPath;
+}
+async function resolveSsrPageEntries(opts) {
+  const absPageDir = path2.resolve(opts.appCwdPath, "page");
+  const hasSt = await Bun.file(path2.join(opts.appCwdPath, "lib", "st.ts")).exists();
+  const basePaths = opts.basePaths ?? [];
+  const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
+  const rootBoundaries = findRootBoundaries(opts.pageKeys, opts.appCwdPath, basePaths);
+  const rootLayoutKeys = new Set(opts.pageKeys.filter((key) => {
+    const segments = getRootBoundarySegments(key);
+    return segments !== null && isRootBoundarySegments(segments, basePaths);
+  }));
+  const base = await Promise.all(opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map(async (key) => {
+    const userAbsPath = path2.resolve(absPageDir, key);
+    if (OVERRIDES_KEY_RE.test(key)) {
+      const moduleAbsPath = await writeGeneratedOverridesLayoutFile({
+        appCwdPath: opts.appCwdPath,
+        key,
+        userAbsPath
+      });
+      return { key, moduleAbsPath, seedAbsPaths: [userAbsPath] };
+    }
+    return { key, moduleAbsPath: userAbsPath };
+  }));
+  const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
+    key: implicitRootLayoutKey(boundary.segments),
+    moduleAbsPath: await writeGeneratedRootLayoutFile({
+      appCwdPath: opts.appCwdPath,
+      appName: opts.appName,
+      boundary,
+      rootSourceAbsPath,
+      includeStInit: hasSt && boundary.segments.length === 0,
+      includeSystemProvider: !hasAncestorRootBoundary(boundary, rootBoundaries)
+    }),
+    seedAbsPaths: [...new Set([boundary.sourceAbsPath, rootSourceAbsPath].filter((absPath) => absPath !== null))]
+  })));
+  const appCwdAbsPath = path2.resolve(opts.appCwdPath);
+  await Promise.all([
+    pruneGeneratedFiles(path2.join(appCwdAbsPath, IMPLICIT_OVERRIDES_DIR), base.filter(({ key }) => OVERRIDES_KEY_RE.test(key)).map(({ moduleAbsPath }) => moduleAbsPath)),
+    pruneGeneratedFiles(path2.join(appCwdAbsPath, IMPLICIT_LAYOUT_DIR), generated.map(({ moduleAbsPath }) => moduleAbsPath))
+  ]);
+  return [...base, ...generated].sort((a, b) => a.key.localeCompare(b.key));
+}
+async function resolveSsrPageEntriesForApp(app, pageKeys) {
+  const config = await app.getConfig();
+  return resolveSsrPageEntries({ appCwdPath: app.cwdPath, appName: app.name, pageKeys, basePaths: config.basePaths });
+}
+
+// pkgs/@akanjs/devkit/codegenLock.ts
+import { mkdir, open, readFile, rm as rm2, stat } from "fs/promises";
+import path3 from "path";
+import { Logger } from "akanjs/common";
+
+class CodegenLock {
+  static fileName = "codegen.lock";
+  static waitTimeoutMs = 1e4;
+  static unknownHolderStaleMs = 60000;
+  static #pollMs = 25;
+  static #logger = new Logger("CodegenLock");
+  static #queue = Promise.resolve();
+  static pathIn(workspaceRoot) {
+    return path3.join(workspaceRoot, "local", ".akan", CodegenLock.fileName);
+  }
+  static async run(workspaceRoot, label, fn) {
+    const ahead = CodegenLock.#queue;
+    let done;
+    CodegenLock.#queue = new Promise((resolve) => {
+      done = resolve;
+    });
+    try {
+      await CodegenLock.#waitForQueue(ahead, label);
+      return await CodegenLock.#withFileLock(workspaceRoot, label, fn);
+    } finally {
+      done();
+    }
+  }
+  static async#waitForQueue(ahead, label) {
+    let timer = null;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("expired"), CodegenLock.waitTimeoutMs);
+    });
+    try {
+      if (await Promise.race([ahead.then(() => "done"), expired]) === "expired")
+        CodegenLock.#logger.warn(`codegen lock queued past ${CodegenLock.waitTimeoutMs}ms in this process; continuing without waiting (${label})`);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  static async#withFileLock(workspaceRoot, label, fn) {
+    const lockPath = CodegenLock.pathIn(workspaceRoot);
+    await mkdir(path3.dirname(lockPath), { recursive: true }).catch(() => {
+      return;
+    });
+    const held = await CodegenLock.#acquire(lockPath, label);
+    try {
+      return await fn();
+    } finally {
+      if (held)
+        await rm2(lockPath, { force: true }).catch(() => {
+          return;
+        });
+    }
+  }
+  static async#acquire(lockPath, label) {
+    const deadline = Date.now() + CodegenLock.waitTimeoutMs;
+    for (;; ) {
+      const handle = await open(lockPath, "wx").catch(() => null);
+      if (handle) {
+        await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now(), label })).catch(() => {
+          return;
+        });
+        await handle.close().catch(() => {
+          return;
+        });
+        return true;
+      }
+      if (await CodegenLock.#reclaimIfAbandoned(lockPath))
+        continue;
+      if (Date.now() >= deadline) {
+        CodegenLock.#logger.warn(`codegen lock at ${lockPath} held past ${CodegenLock.waitTimeoutMs}ms; continuing without it (${label})`);
+        return false;
+      }
+      await Bun.sleep(CodegenLock.#pollMs);
+    }
+  }
+  static async#reclaimIfAbandoned(lockPath) {
+    const info = await stat(lockPath).catch(() => null);
+    if (!info)
+      return true;
+    const holder = CodegenLock.#parseHolder(await readFile(lockPath, "utf8").catch(() => ""));
+    if (holder) {
+      if (CodegenLock.#isAlive(holder.pid))
+        return false;
+    } else if (Date.now() - info.mtimeMs < CodegenLock.unknownHolderStaleMs)
+      return false;
+    await rm2(lockPath, { force: true }).catch(() => {
+      return;
+    });
+    return true;
+  }
+  static #parseHolder(raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.pid !== "number" || typeof parsed.at !== "number")
+        return null;
+      return { pid: parsed.pid, at: parsed.at, label: typeof parsed.label === "string" ? parsed.label : "" };
+    } catch {
+      return null;
+    }
+  }
+  static #isAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+      return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+}
+
+// pkgs/@akanjs/devkit/spinner.ts
+import ora from "ora";
+
+class Spinner {
+  static padding = 12;
+  static oraOptions = { discardStdin: false };
+  static canAnimate(stream = process.stderr) {
+    return !stream.isTTY || stream.columns > 0;
+  }
+  spinner;
+  stopWatch = null;
+  startAt = new Date;
+  prefix;
+  message;
+  enableSpin;
+  constructor(message, { prefix = "", indent = 0, enableSpin = true } = {}) {
+    Spinner.padding = Math.max(Spinner.padding, prefix.length);
+    this.prefix = prefix;
+    this.message = message;
+    this.spinner = ora({ ...Spinner.oraOptions, text: message });
+    this.spinner.prefixText = prefix.padStart(Spinner.padding, " ");
+    this.spinner.indent = indent;
+    this.enableSpin = enableSpin && Spinner.canAnimate();
+  }
+  start() {
+    this.startAt = new Date;
+    if (this.enableSpin) {
+      this.spinner.start();
+      this.stopWatch = setInterval(() => {
+        this.spinner.prefixText = this.prefix.padStart(Spinner.padding, " ");
+        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr({ floor: true })})`;
+      }, 1000);
+    } else
+      this.spinner.info();
+    return this;
   }
   succeed(message) {
     this.spinner.succeed(`${message} (${this.#getElapsedTimeStr()})`);
@@ -191,18 +504,19 @@ import {
   fork,
   spawn as spawn2
 } from "child_process";
-import { readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import {
   copyFile,
   cp as cpEntry,
-  mkdir as mkdir3,
+  lstat,
+  mkdir as mkdir2,
   readdir as readDirEntries,
   realpath,
   rm as rm3,
   stat as stat2,
   symlink
 } from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 import { pathToFileURL } from "url";
 import {
   capitalize,
@@ -218,7 +532,7 @@ import chalk2 from "chalk";
 
 // pkgs/@akanjs/devkit/agentsIndex.ts
 var recipeScannerLoad = null;
-var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-fpagtgc1.js");
+var loadRecipeScanner = () => recipeScannerLoad ??= import("./recipeScanner-4b69ybe0.js");
 var AGENT_BLOCK_START = "<!-- akan:agent:start -->";
 var AGENT_BLOCK_END = "<!-- akan:agent:end -->";
 var AGENT_VERSION_PREFIX = "<!-- akan:agent:version ";
@@ -228,7 +542,7 @@ ${block}`;
 var extractBlockVersion = (content) => content.match(/<!-- akan:agent:version ([^\s]+) -->/)?.[1] ?? null;
 var readDevkitVersion = async () => {
   const { readFile } = await import("fs/promises");
-  const { getDirname } = await import("./getDirname-dr3jz1xg.js");
+  const { getDirname } = await import("./fileSys-wzzrntkw.js");
   try {
     const raw = await readFile(`${getDirname(import.meta.url)}/package.json`, "utf-8");
     return JSON.parse(raw).version ?? null;
@@ -354,79 +668,93 @@ var renderScopeClaudeMd = (scope) => `# ${scope.name} \u2014 Claude Code Guide
 ${CLAUDE_COMMENT_RULE}
 `;
 
-// pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
-import fs from "fs";
-import path2 from "path";
-import { fileURLToPath } from "url";
-import { normalizeRoutePrefix } from "akanjs/base";
-import { resolveAkanI18nConfig } from "akanjs/common";
+// pkgs/@akanjs/devkit/akanConfig/akanBin.ts
+import path4 from "path";
 
 // pkgs/@akanjs/devkit/akanConfig/types.ts
-import { archs } from "akanjs";
+import { archs, binPlatforms } from "akanjs";
 
+// pkgs/@akanjs/devkit/akanConfig/akanBin.ts
+class AkanBin {
+  static archive = /\.(zip|tar\.gz|tgz|tar\.xz|txz|tar\.bz2|tbz2|tar)$/i;
+  static fileName = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+  static parse(declared, owner, baseDir) {
+    if (declared === undefined)
+      return {};
+    if (!declared || typeof declared !== "object" || Array.isArray(declared))
+      throw new Error(`${owner}: bin maps each executable's name to its platforms`);
+    return Object.fromEntries(Object.entries(declared).map(([name, platforms]) => [name, AkanBin.#platforms(name, platforms, owner, baseDir)]));
+  }
+  static isArchive(source) {
+    return AkanBin.archive.test("url" in source ? new URL(source.url).pathname : source.path);
+  }
+  static #platforms(name, platforms, owner, baseDir) {
+    if (!AkanBin.fileName.test(name))
+      throw new Error(`${owner}: bin.${name} is not a file name`);
+    if (!platforms || typeof platforms !== "object" || Array.isArray(platforms))
+      throw new Error(`${owner}: bin.${name} maps platforms (${binPlatforms.join(", ")}) to where the file comes from`);
+    const resolved = {};
+    for (const [platform, source] of Object.entries(platforms)) {
+      if (!binPlatforms.includes(platform))
+        throw new Error(`${owner}: bin.${name}.${platform} is not one of ${binPlatforms.join(", ")}`);
+      resolved[platform] = AkanBin.#source(`${owner}: bin.${name}.${platform}`, source, baseDir);
+    }
+    return resolved;
+  }
+  static #source(at, source, baseDir) {
+    if (!source || typeof source !== "object" || Array.isArray(source))
+      throw new Error(`${at} must be { url, sha256 } or { path }`);
+    const { url, sha256, path: localPath, file, ...rest } = source;
+    const extra = Object.keys(rest);
+    if (extra.length)
+      throw new Error(`${at}: unknown key ${extra.join(", ")}`);
+    if (url === undefined === (localPath === undefined))
+      throw new Error(`${at} takes either url and sha256, or path`);
+    const resolved = url !== undefined ? AkanBin.#urlSource(at, url, sha256) : AkanBin.#pathSource(at, localPath, sha256, baseDir);
+    const archive = AkanBin.isArchive(resolved);
+    if (file === undefined) {
+      if (archive)
+        throw new Error(`${at} names an archive: file picks the executable inside it`);
+      return resolved;
+    }
+    if (!archive)
+      throw new Error(`${at}: file picks the executable out of an archive, and this source is none`);
+    const parts = typeof file === "string" ? file.split(/[\\/]/).filter((part) => part && part !== ".") : [];
+    if (!parts.length || path4.isAbsolute(file) || parts.includes(".."))
+      throw new Error(`${at}: file must be a path inside the archive (got ${JSON.stringify(file)})`);
+    return { ...resolved, file: parts.join("/") };
+  }
+  static #urlSource(at, url, sha256) {
+    if (typeof url !== "string" || !URL.canParse(url) || !/^https?:$/.test(new URL(url).protocol))
+      throw new Error(`${at}: url must be an http(s) address`);
+    if (typeof sha256 !== "string" || !/^[0-9a-f]{64}$/i.test(sha256))
+      throw new Error(`${at}: sha256 must be the downloaded file's 64-digit hex digest`);
+    return { url, sha256: sha256.toLowerCase() };
+  }
+  static #pathSource(at, localPath, sha256, baseDir) {
+    if (typeof localPath !== "string" || !localPath)
+      throw new Error(`${at}: path must name a file`);
+    if (sha256 !== undefined)
+      throw new Error(`${at}: sha256 checks a download, and a path source downloads nothing`);
+    return { path: path4.resolve(baseDir, localPath) };
+  }
+}
 // pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
+import fs2 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+import { DatabaseModes, normalizeRoutePrefix } from "akanjs/base";
+import { resolveAkanI18nConfig } from "akanjs/common";
 var DEFAULT_BARREL_IMPORTS = ["akanjs/webkit", "akanjs/common", "akanjs/ui", "akanjs/server"];
 var DEFAULT_OPTIMIZE_IMPORTS = [
-  "lucide-react",
-  "date-fns",
-  "lodash-es",
-  "ramda",
-  "antd",
-  "react-bootstrap",
-  "ahooks",
-  "@ant-design/icons",
-  "@headlessui/react",
-  "@headlessui-float/react",
-  "@heroicons/react/20/solid",
-  "@heroicons/react/24/solid",
-  "@heroicons/react/24/outline",
-  "@visx/visx",
-  "@tremor/react",
-  "rxjs",
-  "@mui/material",
-  "@mui/icons-material",
-  "recharts",
-  "react-use",
-  "@material-ui/core",
-  "@material-ui/icons",
-  "@tabler/icons-react",
-  "mui-core",
-  "react-icons/*"
-];
+  "lucide-react date-fns lodash-es ramda antd react-bootstrap ahooks @ant-design/icons @headlessui/react",
+  "@headlessui-float/react @heroicons/react/20/solid @heroicons/react/24/solid @heroicons/react/24/outline",
+  "@visx/visx @tremor/react rxjs @mui/material @mui/icons-material recharts react-use @material-ui/core",
+  "@material-ui/icons @tabler/icons-react mui-core react-icons/*"
+].flatMap((line) => line.split(" "));
 var WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"];
 var DEFAULT_DOCKER_IMAGE = "oven/bun:1-slim";
 var SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"];
-var MOBILE_RUNTIME_PACKAGES = [
-  "@capacitor/cli",
-  "@capacitor/core",
-  "@capacitor/ios",
-  "@capacitor/android",
-  "@capacitor/assets"
-];
-var MOBILE_APP_CAPACITOR_PLUGINS = [
-  "@capacitor/app",
-  "@capacitor/browser",
-  "@capacitor/camera",
-  "@capacitor/core",
-  "@capacitor/device",
-  "@capacitor/geolocation",
-  "@capacitor/haptics",
-  "@capacitor/inappbrowser",
-  "@capacitor/keyboard",
-  "@capacitor/preferences",
-  "@capacitor/push-notifications",
-  "capacitor-plugin-safe-area"
-];
-var DATABASE_MODE_RUNTIME_PACKAGES = {
-  single: [],
-  multiple: ["@libsql/client", "bullmq", "ioredis", "protobufjs"],
-  cluster: ["bullmq", "ioredis", "postgres", "protobufjs"]
-};
-var AKAN_RUNTIME_PACKAGES = new Set([
-  ...SSR_RUNTIME_PACKAGES,
-  ...MOBILE_RUNTIME_PACKAGES,
-  ...Object.values(DATABASE_MODE_RUNTIME_PACKAGES).flat()
-]);
 var DEFAULT_AKAN_IMAGE_CONFIG = {
   deviceSizes: [640, 750, 828, 1080, 1200, 1920, 2048, 3840],
   imageSizes: [32, 48, 64, 96, 128, 256, 384],
@@ -471,26 +799,26 @@ var normalizeDeepLinkDomain = (domain) => {
   }
 };
 var normalizeDeepLinks = (deepLinks) => {
-  if (!deepLinks)
+  const schemes = normalizeStringList(deepLinks?.schemes);
+  const domains = normalizeStringList(deepLinks?.domains?.map(normalizeDeepLinkDomain));
+  if (!schemes && !domains)
     return;
-  const schemes = normalizeStringList(deepLinks.schemes);
-  const domains = normalizeStringList(deepLinks.domains?.map(normalizeDeepLinkDomain));
-  const teamId = deepLinks.ios?.teamId?.trim();
-  const sha256CertFingerprints = normalizeStringList(deepLinks.android?.sha256CertFingerprints);
-  if (!schemes && !domains && !teamId && !sha256CertFingerprints)
-    return;
-  return {
-    ...schemes ? { schemes } : {},
-    ...domains ? { domains } : {},
-    ...teamId ? { ios: { teamId } } : {},
-    ...sha256CertFingerprints ? { android: { sha256CertFingerprints } } : {}
-  };
+  return { ...schemes ? { schemes } : {}, ...domains ? { domains } : {} };
 };
 var emptyLibContributions = () => ({
   externalLibs: [],
+  trustedDependencies: [],
+  bin: [],
   docker: { preRuns: [], postRuns: [] },
   keepFonts: []
 });
+var normalizePackageNames = (names, owner) => {
+  if (names === undefined)
+    return [];
+  if (!Array.isArray(names) || names.some((name) => typeof name !== "string" || !name.trim()))
+    throw new Error(`${owner}: trustedDependencies lists package names`);
+  return [...new Set(names.map((name) => name.trim()))];
+};
 var normalizeKeepFonts = (keepFonts) => [
   ...new Set((keepFonts ?? []).map((glob) => glob.trim().replace(/^\/+/, "")).filter(Boolean))
 ];
@@ -506,17 +834,20 @@ class AkanAppConfig {
   rootPackageJson;
   docker;
   dockerfile;
-  defaultDatabaseMode;
+  database;
   web;
   externalLibs;
+  trustedDependencies;
+  bin;
+  libBins;
   barrelImports;
   optimizeImports;
   images;
   i18n;
   api;
   publicEnv;
-  mobile;
-  hasMobileConfig;
+  native;
+  hasNativeConfig;
   secrets;
   assets;
   syncPageLibs;
@@ -534,8 +865,17 @@ class AkanAppConfig {
     this.baseDevEnv = baseDevEnv;
     this.plugins = plugins;
     this.#applyRoutes(config?.routes);
-    this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
+    this.database = AkanAppConfig.#database(app, config);
     this.externalLibs = [...new Set([...config?.externalLibs ?? [], ...libContributions.externalLibs])];
+    const owner = `apps/${app.name}/akan.config.ts`;
+    this.trustedDependencies = [
+      ...new Set([
+        ...normalizePackageNames(config?.trustedDependencies, owner),
+        ...libContributions.trustedDependencies ?? []
+      ])
+    ];
+    this.bin = AkanBin.parse(config?.bin, owner, app.cwdPath);
+    this.libBins = libContributions.bin ?? [];
     this.barrelImports = [
       ...DEFAULT_BARREL_IMPORTS,
       ...WORKSPACE_BARREL_FACETS.map((facet) => `@apps/${app.name}/${facet}`),
@@ -563,100 +903,202 @@ class AkanAppConfig {
       ]
     };
     this.syncPageLibs = config?.syncPageLibs ?? false;
-    this.hasMobileConfig = Boolean(config.mobile);
-    this.mobile = this.#resolveMobileConfig(config.mobile);
+    if (config.mobile !== undefined)
+      throw new Error(`apps/${this.app.name}/akan.config.ts declares \`mobile\`, which is now \`native\`: the platform settings sit in native.ios, native.android and native.desktop, and a target overrides them under native.targets.<name>.`);
+    this.hasNativeConfig = Boolean(config.native);
+    this.native = this.#resolveNativeConfig(config.native);
     this.web = this.#resolveWebConfig(config.web);
     this.docker = AkanAppConfig.#resolveDocker(config.docker, libContributions.docker);
     this.dockerfile = this.#makeDockerfile();
   }
   #resolveWebConfig(web) {
     const resolved = typeof web === "object" ? { ssr: true, csr: web.csr } : { ssr: web ?? true, csr: web ?? true };
-    if (!resolved.csr && this.hasMobileConfig)
-      throw new Error(`apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares mobile targets; the Capacitor build ships that bundle. Drop the mobile section or leave CSR on.`);
+    if (!resolved.csr && this.hasNativeConfig)
+      throw new Error(`apps/${this.app.name}/akan.config.ts turns the CSR bundle off but declares a native section; the native apps ship that bundle. Drop the native section or leave CSR on.`);
     return resolved;
   }
-  #resolveMobileConfig(mobile) {
-    const {
-      targets: rawTargets,
-      indexPath: _indexPath,
-      ...rawMobile
-    } = mobile ?? {};
-    const appName = rawMobile.appName ?? this.app.name;
-    const appId = rawMobile.appId ?? deriveDefaultAppId(this.baseDevEnv.repoName, this.app.name);
-    const version = rawMobile.version ?? "0.0.1";
-    const buildNum = rawMobile.buildNum ?? 1;
-    const defaultTargetName = this.#defaultMobileTargetName(rawTargets);
-    const targetEntries = Object.entries(rawTargets ?? {
-      [defaultTargetName]: {}
-    });
-    const targets = Object.fromEntries(targetEntries.map(([name, rawTarget]) => {
-      const target = rawTarget;
-      const fallbackBasePath = !rawTargets && this.basePaths.has(name) ? name : undefined;
-      const basePath = (target.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
-      const indexPath = normalizeIndexPath(target.indexPath);
-      const deepLinks = normalizeDeepLinks(target.deepLinks);
-      if (basePath && !this.basePaths.has(basePath)) {
-        throw new Error(`Mobile target '${name}' uses unknown basePath '${basePath}' in apps/${this.app.name}/akan.config.ts`);
-      }
-      const resolved = {
-        ...rawMobile,
-        ...target,
+  #resolveNativeConfig(native) {
+    const configPath = `apps/${this.app.name}/akan.config.ts`;
+    const { targets: rawTargets, ...root } = native ?? {};
+    AkanAppConfig.#assertNativeKeys(root, "native", configPath);
+    AkanAppConfig.#assertFiles(root, "native", configPath);
+    const appName = root.appName ?? this.app.name;
+    const appId = root.appId ?? deriveDefaultAppId(this.baseDevEnv.repoName, this.app.name);
+    const version = root.version ?? "0.0.1";
+    const buildNum = root.buildNum ?? 1;
+    const named = rawTargets !== undefined && Object.keys(rawTargets).length > 0;
+    const entries = named ? Object.entries(rawTargets) : [[this.basePaths.has(this.app.name) ? this.app.name : "default", {}]];
+    const targets = Object.fromEntries(entries.map(([name, own]) => {
+      const where = named ? `native.targets.${name}` : "native";
+      AkanAppConfig.#assertNativeKeys(own ?? {}, where, configPath);
+      const merged = AkanAppConfig.#overlay(root, own ?? {});
+      const fallbackBasePath = !named && this.basePaths.has(name) ? name : undefined;
+      const basePath = (merged.basePath ?? fallbackBasePath)?.replace(/^\/+|\/+$/g, "") || undefined;
+      if (basePath && !this.basePaths.has(basePath))
+        throw new Error(`Native target '${name}' uses unknown basePath '${basePath}' in ${configPath}`);
+      const { updates } = merged;
+      if (updates && (!updates.url || !updates.publicKey))
+        throw new Error(`${where}.updates in ${configPath} has no url or publicKey${named ? "; give them in native.updates or the target's own" : ""}.`);
+      AkanAppConfig.#assertFiles(own ?? {}, where, configPath);
+      const {
+        basePath: _basePath,
+        indexPath: rawIndexPath,
+        deepLinks: rawDeepLinks,
+        updates: _updates,
+        ...rest
+      } = merged;
+      const indexPath = normalizeIndexPath(rawIndexPath);
+      const deepLinks = normalizeDeepLinks(rawDeepLinks);
+      const { teamId: rawTeamId, ...iosRest } = AkanAppConfig.#platformIndexPath(merged.ios ?? {});
+      const teamId = rawTeamId?.trim();
+      const { sha256CertFingerprints: rawFingerprints, ...androidRest } = AkanAppConfig.#platformIndexPath(merged.android ?? {});
+      const fingerprints = normalizeStringList(rawFingerprints);
+      const target = {
+        ...rest,
         name,
-        basePath,
-        indexPath,
-        deepLinks,
-        appName: target.appName ?? appName,
-        appId: target.appId ?? appId,
-        version: target.version ?? version,
-        buildNum: target.buildNum ?? buildNum,
-        plugins: {
-          ...rawMobile.plugins,
-          ...target.plugins
-        },
-        android: {
-          ...rawMobile.android,
-          ...target.android
-        },
-        ios: {
-          ...rawMobile.ios,
-          ...target.ios
-        }
+        ...basePath ? { basePath } : {},
+        ...indexPath ? { indexPath } : {},
+        ...deepLinks ? { deepLinks } : {},
+        ...merged.ios ? { ios: { ...iosRest, ...teamId ? { teamId } : {} } } : {},
+        ...merged.android ? { android: { ...androidRest, ...fingerprints ? { sha256CertFingerprints: fingerprints } : {} } } : {},
+        ...merged.desktop ? {
+          desktop: AkanAppConfig.#desktopServer(AkanAppConfig.#platformIndexPath(merged.desktop), `${where}.desktop.server`, configPath)
+        } : {},
+        appName: merged.appName ?? this.app.name,
+        appId: merged.appId ?? appId,
+        version: merged.version ?? version,
+        buildNum: merged.buildNum ?? buildNum,
+        ...updates ? { updates } : {}
       };
-      return [name, resolved];
+      return [name, target];
     }));
-    return {
-      ...rawMobile,
-      appName,
-      appId,
-      version,
-      buildNum,
-      targets,
-      plugins: rawMobile.plugins
+    return { appName, appId, ...root.fileName ? { fileName: root.fileName } : {}, version, buildNum, targets };
+  }
+  static #desktopServer(desktop, where, configPath) {
+    const { server } = desktop;
+    if (server === undefined || typeof server === "boolean")
+      return desktop;
+    if (!AkanAppConfig.#isPlainObject(server))
+      throw new Error(`${where} in ${configPath} must be true or { omit: string[] }.`);
+    const omit = server.omit;
+    if (omit !== undefined && (!Array.isArray(omit) || omit.some((name) => typeof name !== "string" || !name.trim())))
+      throw new Error(`${where}.omit in ${configPath} must be a list of package names.`);
+    const names = [...new Set((omit ?? []).map((name) => name.trim()))].sort();
+    return { ...desktop, server: { omit: names } };
+  }
+  static #platformIndexPath(section) {
+    const { indexPath: rawIndexPath, ...rest } = section;
+    const indexPath = normalizeIndexPath(rawIndexPath);
+    return { ...rest, ...indexPath ? { indexPath } : {} };
+  }
+  static #overlay(base, own) {
+    const merge = (kept, value, top, key) => {
+      if (!AkanAppConfig.#isPlainObject(kept) || !AkanAppConfig.#isPlainObject(value))
+        return value;
+      if (top && (key === "icon" || key === "splash"))
+        return value;
+      const out = { ...kept };
+      for (const [inner, next] of Object.entries(value))
+        if (next !== undefined)
+          out[inner] = merge(out[inner], next, false, inner);
+      return out;
     };
-  }
-  #defaultMobileTargetName(rawTargets) {
-    if (rawTargets && Object.keys(rawTargets).length > 0)
-      return Object.keys(rawTargets)[0];
-    return this.basePaths.has(this.app.name) ? this.app.name : "default";
+    const out = { ...base };
+    for (const [key, value] of Object.entries(own))
+      if (value !== undefined)
+        out[key] = merge(out[key], value, true, key);
+    return out;
+  }
+  static #isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  static #nativeKeys = {
+    native: [
+      "basePath",
+      "indexPath",
+      "appName",
+      "appId",
+      "fileName",
+      "version",
+      "buildNum",
+      "icon",
+      "splash",
+      "permissions",
+      "plugins",
+      "deepLinks",
+      "updates",
+      "ios",
+      "android",
+      "desktop"
+    ],
+    ios: ["indexPath", "teamId", "infoPlist", "entitlements", "privacy", "files"],
+    android: [
+      "indexPath",
+      "sha256CertFingerprints",
+      "googleServices",
+      "push",
+      "autoplay",
+      "manifest",
+      "application",
+      "activity",
+      "files"
+    ],
+    desktop: ["indexPath", "server", "recovery", "window", "screenCapture", "entitlements"],
+    desktopServer: ["omit"],
+    deepLinks: ["schemes", "domains"]
+  };
+  static #movedKeys = {
+    native: "the platform sections and plugins sit directly in the native section: ios, android, desktop, plugins",
+    assets: "icon and splash sit directly in the native section",
+    files: "ios.files (keyed by the path in the app bundle) or android.files (keyed res/<type>/<file> or assets/<path>)",
+    push: "android.push",
+    privacy: "ios.privacy",
+    "deepLinks.ios": "ios.teamId",
+    "deepLinks.android": "android.sha256CertFingerprints"
+  };
+  static #assertNativeKeys(section, where, configPath) {
+    const check = (value, known, at, kind) => {
+      if (!AkanAppConfig.#isPlainObject(value))
+        return;
+      for (const key of Object.keys(value)) {
+        if (known.includes(key))
+          continue;
+        const moved = AkanAppConfig.#movedKeys[kind === "native" ? key : `${kind}.${key}`];
+        throw new Error(moved ? `${at}.${key} in ${configPath} has moved: ${moved}.` : `${at}.${key} in ${configPath} is not a native setting. Known: ${known.join(", ")}.`);
+      }
+    };
+    check(section, AkanAppConfig.#nativeKeys.native, where, "native");
+    const settings = section;
+    check(settings.ios, AkanAppConfig.#nativeKeys.ios, `${where}.ios`, "ios");
+    check(settings.android, AkanAppConfig.#nativeKeys.android, `${where}.android`, "android");
+    check(settings.desktop, AkanAppConfig.#nativeKeys.desktop, `${where}.desktop`, "desktop");
+    check(settings.desktop?.server, AkanAppConfig.#nativeKeys.desktopServer, `${where}.desktop.server`, "desktopServer");
+    check(settings.deepLinks, AkanAppConfig.#nativeKeys.deepLinks, `${where}.deepLinks`, "deepLinks");
+  }
+  static #androidFilePattern = /^(?:res\/[^/]+\/[^/]+|assets\/.+)$/;
+  static #assertFiles(settings, where, configPath) {
+    const check = (files, at, valid, shape) => {
+      for (const [to, from] of Object.entries(files ?? {})) {
+        if (typeof from !== "string")
+          throw new Error(`${at}["${to}"] in ${configPath} must name its source file, relative to the app folder, e.g. { "${shape}": "assets/chime.mp3" }.`);
+        if (!valid(to))
+          throw new Error(`${at}["${to}"] in ${configPath} must land at ${shape}.`);
+      }
+    };
+    check(settings.ios?.files, `${where}.ios.files`, (to) => to.length > 0 && !to.startsWith("/") && !to.split("/").includes(".."), "<path in the app bundle>");
+    check(settings.android?.files, `${where}.android.files`, (to) => AkanAppConfig.#androidFilePattern.test(to), "res/<type>/<file> or assets/<path>");
   }
   #applyRoutes(routes = []) {
     for (const route of routes) {
-      if (route.basePath) {
-        const basePath = route.basePath.replace(/^\/+|\/+$/g, "");
+      const basePath = route.basePath ? route.basePath.replace(/^\/+|\/+$/g, "") : null;
+      if (basePath !== null)
         this.basePaths.add(basePath);
-        const domains = this.subRoutes.getOrInsert(basePath, new Set);
-        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
-        Object.values(route.domains).flat().forEach((domain) => {
-          if (domain)
-            domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
-        });
-      } else {
-        Object.keys(route.domains).forEach((branch) => void this.branches.add(branch));
-        Object.values(route.domains).flat().forEach((domain) => {
-          if (domain)
-            this.domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
-        });
-      }
+      const domains = basePath !== null ? this.subRoutes.getOrInsert(basePath, new Set) : this.domains;
+      for (const branch of Object.keys(route.domains))
+        this.branches.add(branch);
+      for (const domain of Object.values(route.domains).flat())
+        if (domain)
+          domains.add(domain.toLowerCase().replace(/:\d+$/, ""));
     }
     const appName = this.app.name.toLowerCase();
     const serveDomain = this.baseDevEnv.serveDomain.toLowerCase();
@@ -693,18 +1135,37 @@ class AkanAppConfig {
       command: docker?.command ?? ["bun", "main.js"]
     };
   }
-  #makeDockerfile() {
+  getProductionEnv(environment = this.baseDevEnv.env) {
+    return {
+      PORT: "8282",
+      NODE_ENV: "production",
+      AKAN_PUBLIC_REPO_NAME: this.baseDevEnv.repoName,
+      AKAN_PUBLIC_SERVE_DOMAIN: this.baseDevEnv.serveDomain,
+      AKAN_PUBLIC_APP_NAME: this.app.name,
+      AKAN_PUBLIC_ENV: environment,
+      ...this.basePaths.size ? { AKAN_PUBLIC_BASE_PATHS: [...this.basePaths].join(",") } : {},
+      AKAN_PUBLIC_DEFAULT_LOCALE: this.i18n.defaultLocale,
+      AKAN_PUBLIC_LOCALES: this.i18n.locales.join(","),
+      AKAN_PUBLIC_API_PREFIX: this.api.prefix,
+      AKAN_PUBLIC_WS_PREFIX: this.api.websocketPrefix,
+      AKAN_PUBLIC_OPERATION_MODE: "cloud",
+      AKAN_DATABASE_MODES: this.database.modes.join(","),
+      AKAN_LOG_TO_FILE: "0",
+      ...this.web.ssr ? {} : { AKAN_SSR: "false" },
+      ...this.web.csr ? {} : { AKAN_CSR: "false" }
+    };
+  }
+  dockerfileFor(environment) {
+    return this.#makeDockerfile(environment);
+  }
+  #makeDockerfile(environment) {
     if (typeof this.docker === "string")
       return this.docker;
     const { image, preRuns, postRuns, command } = this.docker;
     const preRunScripts = this.#getDockerRunScripts(preRuns);
     const postRunScripts = this.#getDockerRunScripts(postRuns);
     const imageScript = this.#getDockerImageScript(image, DEFAULT_DOCKER_IMAGE);
-    const webEnvLines = [
-      ...this.web.ssr ? [] : ["ENV AKAN_SSR=false"],
-      ...this.web.csr ? [] : ["ENV AKAN_CSR=false"]
-    ].join(`
-`);
+    const envLines = Object.entries(this.getProductionEnv(environment)).map(([key, value]) => `ENV ${key}=${value}`);
     return `${imageScript}
 RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends ca-certificates tzdata && rm -rf /var/lib/apt/lists/*
 RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
@@ -718,20 +1179,8 @@ RUN bun install --production
 ${postRunScripts.join(`
 `)}
 COPY . .
-ENV PORT=8282
-ENV NODE_ENV=production
-ENV AKAN_PUBLIC_REPO_NAME=${this.baseDevEnv.repoName}
-ENV AKAN_PUBLIC_SERVE_DOMAIN=${this.baseDevEnv.serveDomain}
-ENV AKAN_PUBLIC_APP_NAME=${this.app.name}
-ENV AKAN_PUBLIC_ENV=${this.baseDevEnv.env}
-${this.basePaths.size ? `ENV AKAN_PUBLIC_BASE_PATHS=${[...this.basePaths].join(",")}` : ""}
-ENV AKAN_PUBLIC_DEFAULT_LOCALE=${this.i18n.defaultLocale}
-ENV AKAN_PUBLIC_LOCALES=${this.i18n.locales.join(",")}
-ENV AKAN_PUBLIC_API_PREFIX=${this.api.prefix}
-ENV AKAN_PUBLIC_WS_PREFIX=${this.api.websocketPrefix}
-ENV AKAN_PUBLIC_OPERATION_MODE=cloud
-ENV AKAN_LOG_TO_FILE=0
-${webEnvLines}
+${envLines.join(`
+`)}
 CMD [${command.map((c) => `"${c}"`).join(",")}]`;
   }
   static #importGeneration = 0;
@@ -743,7 +1192,7 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
   static async from(app, { bustImportCache = false } = {}) {
     const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
       AkanAppConfig.importConfigModule(app.cwdPath, { bustImportCache }),
-      WorkspaceExecutor.getBaseDevEnv(path2.join(app.workspace.workspaceRoot, ".env")),
+      WorkspaceExecutor.getBaseDevEnv(path5.join(app.workspace.workspaceRoot, ".env")),
       app.workspace.getLibs(),
       app.workspace.getPackageJson()
     ]);
@@ -753,503 +1202,159 @@ CMD [${command.map((c) => `"${c}"`).join(",")}]`;
     return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv, plugins ?? [], libContributions);
   }
   static async#collectLibContributions(app, libs, bustImportCache) {
-    const libConfigs = await Promise.all(libs.map(async (libName) => LibExecutor.from(app, libName).getConfig({ refresh: bustImportCache }).catch((error) => {
-      app.logger.warn(`Skipped libs/${libName}/akan.config.ts contributions: ${String(error)}`);
-      return null;
-    })));
-    return {
-      externalLibs: libConfigs.flatMap((libConfig) => libConfig?.externalLibs ?? []),
-      docker: {
-        preRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.preRuns ?? []),
-        postRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.postRuns ?? [])
-      },
-      keepFonts: libConfigs.flatMap((libConfig) => (libConfig?.assets.keepFonts ?? []).map((glob) => `libs/${libConfig?.lib.name}/${glob}`))
-    };
-  }
-  #resolveProductionDependencyVersion(lib) {
-    const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
-    if (rootVersion)
-      return rootVersion;
-    const akanPackageJson = getAkanPackageJson();
-    return akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
-  }
-  #getProductionRuntimePackages() {
-    return [...this.externalLibs, ...SSR_RUNTIME_PACKAGES, ...this.getDatabaseModeRuntimePackages()];
-  }
-  getDatabaseModeRuntimePackages(databaseMode = this.defaultDatabaseMode) {
-    return [...DATABASE_MODE_RUNTIME_PACKAGES[databaseMode]];
-  }
-  getMissingDatabaseModeDependencySpecs(databaseMode = this.defaultDatabaseMode) {
-    return this.#getMissingDependencySpecs(this.getDatabaseModeRuntimePackages(databaseMode));
-  }
-  getMobileRuntimePackages() {
-    return [...new Set([...MOBILE_RUNTIME_PACKAGES, ...MOBILE_APP_CAPACITOR_PLUGINS])];
-  }
-  getMissingMobileDependencySpecs() {
-    return this.#getMissingDependencySpecs(this.getMobileRuntimePackages());
-  }
-  getMobileAppCapacitorPlugins() {
-    return [...MOBILE_APP_CAPACITOR_PLUGINS];
-  }
-  #getMissingDependencySpecs(libs) {
-    const rootDependencies = {
-      ...this.rootPackageJson.dependencies,
-      ...this.rootPackageJson.devDependencies
-    };
-    return libs.filter((lib) => !rootDependencies[lib]).map((lib) => {
-      const version = this.#resolveProductionDependencyVersion(lib);
-      if (!version)
-        throw new Error(`Dependency ${lib} not found in package.json`);
-      return `${lib}@${version}`;
-    });
-  }
-  getProductionPackageJson(data = {}) {
-    return {
-      name: this.app.name,
-      description: this.app.name,
-      version: "1.0.0",
-      main: "./main.js",
-      dependencies: Object.fromEntries([...new Set(this.#getProductionRuntimePackages())].map((lib) => {
-        const version = this.#resolveProductionDependencyVersion(lib);
-        if (!version)
-          throw new Error(`Dependency ${lib} not found in package.json`);
-        return [lib, version];
-      })),
-      ...data
-    };
-  }
-}
-var akanPackageJson = null;
-function getAkanPackageJson() {
-  if (akanPackageJson)
-    return akanPackageJson;
-  const sourceDir = path2.dirname(fileURLToPath(import.meta.url));
-  const packageJsonPaths = [
-    path2.join(sourceDir, "../../../akanjs/package.json"),
-    path2.join(process.cwd(), "pkgs/akanjs/package.json"),
-    path2.join(path2.dirname(Bun.main), "node_modules/akanjs/package.json")
-  ];
-  try {
-    packageJsonPaths.unshift(Bun.resolveSync("akanjs/package.json", sourceDir));
-  } catch {}
-  for (const packageJsonPath of packageJsonPaths) {
-    try {
-      akanPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-      return akanPackageJson;
-    } catch {}
-  }
-  akanPackageJson = {
-    name: "akanjs",
-    version: "0.0.0",
-    description: "akanjs",
-    dependencies: {}
-  };
-  return akanPackageJson;
-}
-function mergeImageConfig(config = {}) {
-  return {
-    ...DEFAULT_AKAN_IMAGE_CONFIG,
-    ...config,
-    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
-    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
-    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
-    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
-    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
-    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns
-  };
-}
-
-class AkanLibConfig {
-  lib;
-  externalLibs;
-  docker;
-  assets;
-  plugins;
-  constructor(lib, config, plugins = []) {
-    this.lib = lib;
-    this.externalLibs = config?.externalLibs ?? [];
-    this.docker = { preRuns: config?.docker?.preRuns ?? [], postRuns: config?.docker?.postRuns ?? [] };
-    this.assets = { keepFonts: normalizeKeepFonts(config?.assets?.keepFonts) };
-    this.plugins = plugins;
-  }
-  static async from(lib, { bustImportCache = false } = {}) {
-    const configImp = await AkanAppConfig.importConfigModule(lib.cwdPath, { bustImportCache });
-    const resolved = typeof configImp === "function" ? configImp(lib) : configImp;
-    const { plugins, ...config } = resolved ?? {};
-    return new AkanLibConfig(lib, config, plugins ?? []);
-  }
-}
-//! need to refactor
-var increaseBuildNum = async (app) => {
-  const appConfig = await AkanAppConfig.from(app);
-  const akanConfigPath = path2.join(app.cwdPath, "akan.config.ts");
-  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
-  const akanConfigContent = akanConfig.replace(`buildNum: ${appConfig.mobile.buildNum}`, `buildNum: ${appConfig.mobile.buildNum + 1}`);
-  fs.writeFileSync(akanConfigPath, akanConfigContent);
-};
-var decreaseBuildNum = async (app) => {
-  const appConfig = await AkanAppConfig.from(app);
-  const akanConfigPath = path2.join(app.cwdPath, "akan.config.ts");
-  const akanConfig = fs.readFileSync(akanConfigPath, "utf8");
-  const akanConfigContent = akanConfig.replace(`buildNum: ${appConfig.mobile.buildNum}`, `buildNum: ${appConfig.mobile.buildNum - 1}`);
-  fs.writeFileSync(akanConfigPath, akanConfigContent);
-};
-// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import path4 from "path";
-
-// pkgs/@akanjs/devkit/transforms/asyncDefaultExportDetector.ts
-import fs2 from "fs";
-import path3 from "path";
-
-class AsyncDefaultExportDetector {
-  static #typescriptLoad;
-  static #loadTypescript() {
-    AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then((mod) => mod.default ?? mod);
-    return AsyncDefaultExportDetector.#typescriptLoad;
-  }
-  static async detect(moduleAbsPath) {
-    try {
-      const typescript = await AsyncDefaultExportDetector.#loadTypescript();
-      const source = fs2.readFileSync(path3.resolve(moduleAbsPath), "utf8");
-      const sourceFile = typescript.createSourceFile(moduleAbsPath, source, typescript.ScriptTarget.Latest, true, AsyncDefaultExportDetector.#scriptKind(typescript, moduleAbsPath));
-      return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
-    } catch {
-      return false;
-    }
-  }
-  #ts;
-  constructor(typescript) {
-    this.#ts = typescript;
-  }
-  detectInSourceFile(sourceFile) {
-    const ts = this.#ts;
-    const asyncBindings = new Map;
-    let defaultIdentifier = null;
-    for (const statement of sourceFile.statements) {
-      if (ts.isFunctionDeclaration(statement)) {
-        if (this.#hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
-          return this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword);
-        }
-        if (statement.name) {
-          asyncBindings.set(statement.name.text, this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword));
-        }
-        continue;
-      }
-      if (ts.isVariableStatement(statement)) {
-        for (const declaration of statement.declarationList.declarations) {
-          if (!ts.isIdentifier(declaration.name))
-            continue;
-          asyncBindings.set(declaration.name.text, this.#isAsyncFunctionExpression(declaration.initializer));
-        }
-        continue;
-      }
-      if (ts.isExportAssignment(statement)) {
-        if (this.#isAsyncFunctionExpression(statement.expression))
-          return true;
-        if (ts.isCallExpression(statement.expression))
-          return true;
-        if (ts.isIdentifier(statement.expression))
-          defaultIdentifier = statement.expression.text;
-        continue;
-      }
-      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
-        const exportClause = statement.exportClause;
-        for (const specifier of exportClause.elements) {
-          if (specifier.name.text !== "default")
-            continue;
-          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
-        }
-      }
-    }
-    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
+    const libConfigs = await Promise.all(libs.map(async (libName) => LibExecutor.from(app, libName).getConfig({ refresh: bustImportCache }).catch((error) => {
+      app.logger.warn(`Skipped libs/${libName}/akan.config.ts contributions: ${String(error)}`);
+      return null;
+    })));
+    return {
+      externalLibs: libConfigs.flatMap((libConfig) => libConfig?.externalLibs ?? []),
+      trustedDependencies: libConfigs.flatMap((libConfig) => libConfig?.trustedDependencies ?? []),
+      bin: libConfigs.flatMap((libConfig) => libConfig && Object.keys(libConfig.bin).length ? [{ lib: libConfig.lib.name, bin: libConfig.bin }] : []),
+      docker: {
+        preRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.preRuns ?? []),
+        postRuns: libConfigs.flatMap((libConfig) => libConfig?.docker.postRuns ?? [])
+      },
+      keepFonts: libConfigs.flatMap((libConfig) => (libConfig?.assets.keepFonts ?? []).map((glob) => `libs/${libConfig?.lib.name}/${glob}`))
+    };
   }
-  #hasModifier(node, kind) {
-    const ts = this.#ts;
-    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+  #resolveProductionDependencyVersion(lib) {
+    const rootVersion = this.rootPackageJson.dependencies?.[lib] ?? this.rootPackageJson.devDependencies?.[lib];
+    if (rootVersion)
+      return rootVersion;
+    const akanPackageJson = getAkanPackageJson();
+    const version = akanPackageJson.dependencies?.[lib] ?? akanPackageJson.peerDependencies?.[lib];
+    if (!version)
+      throw new Error(`Dependency ${lib} not found in package.json`);
+    return version;
   }
-  #isAsyncFunctionExpression(node) {
-    const ts = this.#ts;
-    return Boolean(node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword));
+  #getProductionRuntimePackages() {
+    return [
+      ...this.externalLibs,
+      ...SSR_RUNTIME_PACKAGES,
+      ...this.database.modes.flatMap((mode) => this.getDatabaseModeRuntimePackages(mode))
+    ];
   }
-  static #scriptKind(typescript, moduleAbsPath) {
-    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx") ? typescript.ScriptKind.TSX : typescript.ScriptKind.TS;
+  getDatabaseModeRuntimePackages(databaseMode) {
+    return [...DatabaseModes.drivers[databaseMode]];
   }
-}
-
-// pkgs/@akanjs/devkit/artifact/implicitRootLayout.ts
-var LAYOUT_KEY_RE = /^\.\/(.+\/)?_layout\.(tsx|ts|jsx|js)$/;
-async function appHasStModule(appCwdPath) {
-  return Bun.file(path4.join(appCwdPath, "lib", "st.ts")).exists();
-}
-var IMPLICIT_LAYOUT_DIR = path4.join(".akan", "generated", "root-layouts");
-var IMPLICIT_DICT_DIR = path4.join(".akan", "generated", "dict");
-var IMPLICIT_OVERRIDES_DIR = path4.join(".akan", "generated", "overrides");
-var OVERRIDES_KEY_RE = /^\.\/(.+\/)?_overrides\.(tsx|ts|jsx|js)$/;
-async function writeGeneratedOverridesLayoutFile(opts) {
-  const filename = `${opts.key.replace(/^\.\//, "").replace(/[^a-zA-Z0-9]+/g, "_")}.tsx`;
-  const absPath = path4.join(path4.resolve(opts.appCwdPath), IMPLICIT_OVERRIDES_DIR, filename);
-  const userRel = path4.relative(path4.dirname(absPath), opts.userAbsPath).split(path4.sep).join("/");
-  const userSpecifier = userRel.startsWith(".") ? userRel : `./${userRel}`;
-  const source = `"use client";
-import { UiOverrideProvider } from "akanjs/ui";
-import { createElement, type ReactNode } from "react";
-import value from ${JSON.stringify(userSpecifier)};
-
-export default function AkanUiOverridesLayout({ children }: { children?: ReactNode }) {
-  return createElement(UiOverrideProvider, { value }, children);
-}
-`;
-  await Bun.write(absPath, source);
-  return absPath;
-}
-function getRootBoundarySegments(key) {
-  const match = LAYOUT_KEY_RE.exec(key);
-  if (!match)
-    return null;
-  const prefix = match[1]?.replace(/\/$/, "");
-  if (!prefix)
-    return [];
-  return prefix.split("/").filter(Boolean);
-}
-function implicitRootLayoutKey(segments) {
-  return `./${[...segments, "__root_layout"].join("/")}.tsx`;
-}
-function implicitRootLayoutAbsPath(appCwdPath, segments) {
-  const filename = segments.length ? `${segments.join("__")}__root_layout.tsx` : "__root_layout.tsx";
-  return path4.join(path4.resolve(appCwdPath), IMPLICIT_LAYOUT_DIR, filename);
-}
-function implicitDictionaryMacroAbsPath(appCwdPath) {
-  return path4.join(path4.resolve(appCwdPath), IMPLICIT_DICT_DIR, "useDict.ts");
-}
-function isRootBoundarySegments(segments, basePaths) {
-  const firstVisibleIndex = segments.findIndex((segment) => !/^\(.+\)$/.test(segment));
-  if (firstVisibleIndex === -1)
-    return segments.length <= 1;
-  if (segments.slice(firstVisibleIndex + 1).some((segment) => /^\(.+\)$/.test(segment)))
-    return false;
-  const visible = segments.slice(firstVisibleIndex);
-  const allowedBasePaths = new Set([...basePaths].map((basePath) => basePath.trim()).filter(Boolean));
-  return visible.length === 1 && (firstVisibleIndex > 0 || allowedBasePaths.has(visible[0] ?? ""));
-}
-function findRootBoundaries(pageKeys, appCwdPath, basePaths) {
-  const boundaries = new Map;
-  for (const key of pageKeys) {
-    const segments = getRootBoundarySegments(key);
-    if (!segments)
-      continue;
-    if (!isRootBoundarySegments(segments, basePaths))
-      continue;
-    const id = segments.join("/");
-    boundaries.set(id, {
-      sourceKey: key,
-      sourceAbsPath: path4.resolve(appCwdPath, "page", key.replace(/^\.\//, "")),
-      segments
+  getMissingDatabaseModeDependencySpecs(databaseMode) {
+    return this.#getMissingDependencySpecs(this.getDatabaseModeRuntimePackages(databaseMode));
+  }
+  resolveDatabaseMode() {
+    return DatabaseModes.resolve({
+      requested: process.env.AKAN_DATABASE_MODE,
+      declared: this.database.modes.join(","),
+      local: true
     });
   }
-  const hasExplicitRootBoundary = [...boundaries.values()].some((boundary) => boundary.segments.length === 0);
-  if (!hasExplicitRootBoundary && boundaries.size === 0) {
-    boundaries.set("", { sourceKey: null, sourceAbsPath: null, segments: [] });
+  static #database(app, config) {
+    const declared = config?.database?.modes?.filter((mode) => !!mode);
+    const modes = declared?.length ? declared : ["single"];
+    return { modes: DatabaseModes.parseList(modes.join(","), `database.modes in apps/${app.name}/akan.config.ts`) };
   }
-  return [...boundaries.values()].sort((a, b) => a.segments.join("/").localeCompare(b.segments.join("/")));
-}
-function hasAncestorRootBoundary(boundary, boundaries) {
-  return boundaries.some((candidate) => candidate !== boundary && candidate.segments.length < boundary.segments.length && candidate.segments.every((segment, index) => boundary.segments[index] === segment));
-}
-function findExplicitRootLayoutAbsPath(pageKeys, appCwdPath) {
-  const rootLayoutKey = pageKeys.find((key) => {
-    const segments = getRootBoundarySegments(key);
-    return segments !== null && segments.length === 0;
-  });
-  return rootLayoutKey ? path4.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 = path4.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`);
+  #getMissingDependencySpecs(libs) {
+    const rootDependencies = {
+      ...this.rootPackageJson.dependencies,
+      ...this.rootPackageJson.devDependencies
+    };
+    return libs.filter((lib) => !rootDependencies[lib]).map((lib) => `${lib}@${this.#resolveProductionDependencyVersion(lib)}`);
+  }
+  get akanVersion() {
+    return getAkanPackageJson().version;
+  }
+  getProductionPackageJson(data = {}) {
+    return {
+      name: this.app.name,
+      description: this.app.name,
+      version: "1.0.0",
+      main: "./main.js",
+      dependencies: Object.fromEntries([...new Set(this.#getProductionRuntimePackages())].map((lib) => [
+        lib,
+        this.#resolveProductionDependencyVersion(lib)
+      ])),
+      ...this.trustedDependencies.length ? { trustedDependencies: this.trustedDependencies } : {},
+      ...data
+    };
   }
 }
-async function writeGeneratedDictionaryMacroFile(appCwdPath, appName) {
-  const absPath = implicitDictionaryMacroAbsPath(appCwdPath);
-  await mkdir2(path4.dirname(absPath), { recursive: true });
-  await Bun.write(absPath, `import { getAllDictionary } from "@apps/${appName}/lib/dict" with { type: "macro" };
-
-export const allDictionary = getAllDictionary();
-`);
-  return absPath;
-}
-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 mkdir2(path4.dirname(absPath), { recursive: true });
-  const dictMacroRel = dictMacroAbsPath ? path4.relative(path4.dirname(absPath), dictMacroAbsPath).split(path4.sep).join("/") : null;
-  const dictMacroSpecifier = dictMacroRel ? dictMacroRel.startsWith(".") ? dictMacroRel : `./${dictMacroRel}` : null;
-  const sourceRel = opts.boundary.sourceAbsPath ? path4.relative(path4.dirname(absPath), opts.boundary.sourceAbsPath).split(path4.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 ? path4.relative(path4.dirname(absPath), inheritedSourceAbsPath).split(path4.sep).join("/") : null;
-  const inheritedSourceSpecifier = inheritedSourceRel ? inheritedSourceRel.startsWith(".") ? inheritedSourceRel : `./${inheritedSourceRel}` : null;
-  const clientImport = opts.includeStInit ? `import { st } from "@apps/${opts.appName}/client";
-void st;
-` : `import "@apps/${opts.appName}/client";
-`;
-  const inheritedLabel = inheritedSourceAbsPath ? path4.relative(opts.appCwdPath, inheritedSourceAbsPath) : "";
-  const inheritedImport = inheritedSourceSpecifier ? `import * as inheritedModule from ${JSON.stringify(inheritedSourceSpecifier)};
-const inheritedLayout = resolveRouteModule(inheritedModule as never, ${JSON.stringify(inheritedLabel)}).module as LayoutModule;
-` : `const inheritedLayout: LayoutModule = {};
-`;
-  const prefix = routePrefixForSegments(opts.boundary.segments);
-  const userLabel = opts.boundary.sourceAbsPath ? path4.relative(opts.appCwdPath, opts.boundary.sourceAbsPath) : "";
-  const userImport = sourceSpecifier ? `import * as userModule from ${JSON.stringify(sourceSpecifier)};
-const userLayout = resolveRouteModule(userModule as never, ${JSON.stringify(userLabel)}).module as LayoutModule;
-const UserLayout = userLayout.default as (props: LayoutProps) => ReactNode | Promise<ReactNode>;
-` : `const UserLayout = ({ children }: LayoutProps) => children;
-const userLayout: LayoutModule = {};
-`;
-  const isAsyncUserLayout = opts.boundary.sourceAbsPath ? await AsyncDefaultExportDetector.detect(opts.boundary.sourceAbsPath) : false;
-  const userLayoutElement = "<UserLayout params={params} searchParams={searchParams}>{children}</UserLayout>";
-  const layoutSignature = isAsyncUserLayout ? "export default async function GeneratedLayout" : "export default function GeneratedLayout";
-  const layoutBinding = isAsyncUserLayout ? `  const layout =
-    process.env.AKAN_PUBLIC_RENDER_ENV === "csr"
-      ? await UserLayout({ params, searchParams, children })
-      : ${userLayoutElement};
-` : "";
-  const layoutChild = isAsyncUserLayout ? "{layout}" : userLayoutElement;
-  const layoutReturn = isAsyncUserLayout ? "layout" : userLayoutElement;
-  const source = opts.includeSystemProvider ? `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
-import { loadFonts, resolveRouteModule } from "akanjs/client";
-import type { ReactNode } from "react";
-import { System } from "akanjs/ui";
-import { env } from "@apps/${opts.appName}/env/env.client";
-import { allDictionary } from ${JSON.stringify(dictMacroSpecifier)};
-${clientImport}${inheritedImport}${userImport}
-const userFonts = userLayout.fonts ?? inheritedLayout.fonts ?? [];
-const defaultFonts = userFonts.filter((font) => font.default);
-if (defaultFonts.length > 1) throw new Error("[route-convention] only one default font is allowed per root layout");
-const defaultFont = defaultFonts[0];
-const defaultFontClassName = defaultFont ? (defaultFont.className ?? \`font-\${defaultFont.name}\`) : undefined;
-
-export async function generateHead(props: PageProps) {
-  if (userLayout.generateHead) return userLayout.generateHead(props);
-  if (userLayout.head !== undefined) return userLayout.head;
-  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
-  return inheritedLayout.head;
-}
-
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
-export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
-export const Error = userLayout.Error ?? inheritedLayout.Error;
-export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
-
-${layoutSignature}({ children, params, searchParams }: LayoutProps) {
-${layoutBinding}  return (
-    <System.Provider
-      of={GeneratedLayout as never}
-      appName=${JSON.stringify(opts.appName)}
-      ${prefix ? `prefix=${JSON.stringify(prefix)}
-      ` : ""}params={params}
-      manifest={userLayout.manifest ?? inheritedLayout.manifest}
-      env={env}
-      theme={userLayout.theme ?? inheritedLayout.theme}
-      fonts={loadFonts(userFonts)}
-      className={defaultFontClassName}
-      gaTrackingId={userLayout.gaTrackingId ?? inheritedLayout.gaTrackingId}
-      layoutStyle={userLayout.layoutStyle ?? inheritedLayout.layoutStyle}
-      reconnect={userLayout.reconnect ?? inheritedLayout.reconnect ?? false}
-      wsConnect={userLayout.wsConnect ?? inheritedLayout.wsConnect ?? true}
-      allDictionary={process.env.AKAN_PUBLIC_RENDER_ENV === "ssr" ? allDictionary : undefined}
-    >
-      ${layoutChild}
-    </System.Provider>
-  );
-}
-` : `import type { LayoutModule, LayoutProps, PageProps } from "akanjs/client";
-import { resolveRouteModule } from "akanjs/client";
-import type { ReactNode } from "react";
-${inheritedImport}${userImport}
-export async function generateHead(props: PageProps) {
-  if (userLayout.generateHead) return userLayout.generateHead(props);
-  if (userLayout.head !== undefined) return userLayout.head;
-  if (inheritedLayout.generateHead) return inheritedLayout.generateHead(props);
-  return inheritedLayout.head;
-}
-
-export async function generateMetadata(props: PageProps) {
-  if (userLayout.generateMetadata) return userLayout.generateMetadata(props);
-  if (userLayout.metadata !== undefined) return userLayout.metadata;
-  if (inheritedLayout.generateMetadata) return inheritedLayout.generateMetadata(props);
-  return inheritedLayout.metadata;
-}
-
-export const NotFound = userLayout.NotFound ?? inheritedLayout.NotFound;
-export const Error = userLayout.Error ?? inheritedLayout.Error;
-export const pageConfig = userLayout.pageConfig ?? inheritedLayout.pageConfig;
-
-${layoutSignature}({ children, params, searchParams }: LayoutProps) {
-${layoutBinding}  return ${layoutReturn};
-}
-`;
-  await Bun.write(absPath, source);
-  return absPath;
-}
-async function resolveSsrPageEntries(opts) {
-  const absPageDir = path4.resolve(opts.appCwdPath, "page");
-  const hasSt = await appHasStModule(opts.appCwdPath);
-  const basePaths = opts.basePaths ?? [];
-  const rootSourceAbsPath = findExplicitRootLayoutAbsPath(opts.pageKeys, opts.appCwdPath);
-  const rootBoundaries = findRootBoundaries(opts.pageKeys, opts.appCwdPath, basePaths);
-  const rootLayoutKeys = new Set(opts.pageKeys.filter((key) => {
-    const segments = getRootBoundarySegments(key);
-    return segments !== null && isRootBoundarySegments(segments, basePaths);
-  }));
-  const base = await Promise.all(opts.pageKeys.filter((key) => !rootLayoutKeys.has(key)).map(async (key) => {
-    const userAbsPath = path4.resolve(absPageDir, key);
-    if (OVERRIDES_KEY_RE.test(key)) {
-      const moduleAbsPath = await writeGeneratedOverridesLayoutFile({
-        appCwdPath: opts.appCwdPath,
-        key,
-        userAbsPath
-      });
-      return { key, moduleAbsPath, seedAbsPaths: [userAbsPath] };
-    }
-    return { key, moduleAbsPath: userAbsPath };
-  }));
-  const generated = await Promise.all(rootBoundaries.map(async (boundary) => ({
-    key: implicitRootLayoutKey(boundary.segments),
-    moduleAbsPath: await writeGeneratedRootLayoutFile({
-      appCwdPath: opts.appCwdPath,
-      appName: opts.appName,
-      boundary,
-      rootSourceAbsPath,
-      includeStInit: hasSt && boundary.segments.length === 0,
-      includeSystemProvider: !hasAncestorRootBoundary(boundary, rootBoundaries)
-    }),
-    seedAbsPaths: [...new Set([boundary.sourceAbsPath, rootSourceAbsPath].filter((absPath) => absPath !== null))]
-  })));
-  const entries = [...base, ...generated];
-  entries.sort((a, b) => a.key.localeCompare(b.key));
-  return entries;
+var akanPackageJson = null;
+function getAkanPackageJson() {
+  if (akanPackageJson)
+    return akanPackageJson;
+  const sourceDir = path5.dirname(fileURLToPath(import.meta.url));
+  const packageJsonPaths = [
+    path5.join(sourceDir, "../../../akanjs/package.json"),
+    path5.join(process.cwd(), "pkgs/akanjs/package.json"),
+    path5.join(path5.dirname(Bun.main), "node_modules/akanjs/package.json")
+  ];
+  try {
+    packageJsonPaths.unshift(Bun.resolveSync("akanjs/package.json", sourceDir));
+  } catch {}
+  for (const packageJsonPath of packageJsonPaths) {
+    try {
+      akanPackageJson = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+      return akanPackageJson;
+    } catch {}
+  }
+  akanPackageJson = {
+    name: "akanjs",
+    version: "0.0.0",
+    description: "akanjs",
+    dependencies: {}
+  };
+  return akanPackageJson;
 }
-async function resolveSsrPageEntriesForApp(app, pageKeys) {
-  const config = await app.getConfig();
-  return resolveSsrPageEntries({ appCwdPath: app.cwdPath, appName: app.name, pageKeys, basePaths: config.basePaths });
+function mergeImageConfig(config = {}) {
+  return {
+    ...DEFAULT_AKAN_IMAGE_CONFIG,
+    ...config,
+    deviceSizes: config.deviceSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.deviceSizes,
+    imageSizes: config.imageSizes ?? DEFAULT_AKAN_IMAGE_CONFIG.imageSizes,
+    formats: config.formats ?? DEFAULT_AKAN_IMAGE_CONFIG.formats,
+    qualities: config.qualities ?? DEFAULT_AKAN_IMAGE_CONFIG.qualities,
+    remotePatterns: config.remotePatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.remotePatterns,
+    localPatterns: config.localPatterns ?? DEFAULT_AKAN_IMAGE_CONFIG.localPatterns
+  };
 }
 
+class AkanLibConfig {
+  lib;
+  externalLibs;
+  trustedDependencies;
+  bin;
+  docker;
+  assets;
+  plugins;
+  constructor(lib, config, plugins = []) {
+    this.lib = lib;
+    this.externalLibs = config?.externalLibs ?? [];
+    const owner = `libs/${lib.name}/akan.config.ts`;
+    this.trustedDependencies = normalizePackageNames(config?.trustedDependencies, owner);
+    this.bin = AkanBin.parse(config?.bin, owner, lib.cwdPath);
+    this.docker = { preRuns: config?.docker?.preRuns ?? [], postRuns: config?.docker?.postRuns ?? [] };
+    this.assets = { keepFonts: normalizeKeepFonts(config?.assets?.keepFonts) };
+    this.plugins = plugins;
+  }
+  static async from(lib, { bustImportCache = false } = {}) {
+    const configImp = await AkanAppConfig.importConfigModule(lib.cwdPath, { bustImportCache });
+    const resolved = typeof configImp === "function" ? configImp(lib) : configImp;
+    const { plugins, ...config } = resolved ?? {};
+    return new AkanLibConfig(lib, config, plugins ?? []);
+  }
+}
+//! need to refactor
+var shiftBuildNum = async (app, delta) => {
+  const { buildNum } = (await AkanAppConfig.from(app)).native;
+  const akanConfigPath = path5.join(app.cwdPath, "akan.config.ts");
+  const akanConfig = fs2.readFileSync(akanConfigPath, "utf8");
+  fs2.writeFileSync(akanConfigPath, akanConfig.replace(`buildNum: ${buildNum}`, `buildNum: ${buildNum + delta}`));
+};
+var increaseBuildNum = async (app) => await shiftBuildNum(app, 1);
+var decreaseBuildNum = async (app) => await shiftBuildNum(app, -1);
 // pkgs/@akanjs/devkit/linter.ts
 import { spawn } from "child_process";
 import { existsSync, readFileSync } from "fs";
-import path5 from "path";
+import path6 from "path";
 import chalk from "chalk";
 var parseBiomeReport = (output) => {
   for (let start = output.indexOf("{");start !== -1; start = output.indexOf("{", start + 1)) {
@@ -1299,20 +1404,29 @@ var asBiomeReport = (candidate) => {
   }
 };
 var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
+var emptyResult = (filePath) => ({
+  filePath,
+  messages: [],
+  errorCount: 0,
+  warningCount: 0,
+  fixableErrorCount: 0,
+  fixableWarningCount: 0
+});
 
 class Linter {
+  static biomeBinName = process.platform === "win32" ? "biome.exe" : "biome";
   lintRoot;
   configPath;
   #biomeBin;
   constructor(cwdPath) {
     this.lintRoot = this.#findBiomeRootPath(cwdPath);
-    this.configPath = Linter.#configPathIn(this.lintRoot) ?? path5.join(this.lintRoot, "biome.json");
-    const localBiomeBin = path5.join(this.lintRoot, "node_modules/.bin/biome");
+    this.configPath = Linter.#configPathIn(this.lintRoot) ?? path6.join(this.lintRoot, "biome.json");
+    const localBiomeBin = path6.join(this.lintRoot, "node_modules", ".bin", Linter.biomeBinName);
     this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
   }
   static #configPathIn(dir) {
     for (const fileName of BIOME_CONFIG_FILES) {
-      const configPath = path5.join(dir, fileName);
+      const configPath = path6.join(dir, fileName);
       if (existsSync(configPath))
         return configPath;
     }
@@ -1321,19 +1435,19 @@ class Linter {
   #findBiomeRootPath(dir) {
     if (Linter.#configPathIn(dir))
       return dir;
-    const parentDir = path5.dirname(dir);
+    const parentDir = path6.dirname(dir);
     if (parentDir === dir)
       throw new Error(`biome.json not found from ${dir}`);
     return this.#findBiomeRootPath(parentDir);
   }
   #toBiomePath(filePath) {
-    const relativePath = path5.relative(this.lintRoot, filePath);
-    if (!relativePath.startsWith("..") && !path5.isAbsolute(relativePath))
+    const relativePath = path6.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path6.isAbsolute(relativePath))
       return relativePath;
     return filePath;
   }
   #resolveFilePath(filePath) {
-    return path5.isAbsolute(filePath) ? filePath : path5.join(this.lintRoot, filePath);
+    return path6.isAbsolute(filePath) ? filePath : path6.join(this.lintRoot, filePath);
   }
   async#runBiome(args, input) {
     return await new Promise((resolve, reject) => {
@@ -1358,7 +1472,7 @@ class Linter {
     const diagnosticPath = diagnostic.location?.path;
     if (!diagnosticPath)
       return fallbackFilePath;
-    return path5.isAbsolute(diagnosticPath) ? diagnosticPath : path5.join(this.lintRoot, diagnosticPath);
+    return path6.isAbsolute(diagnosticPath) ? diagnosticPath : path6.join(this.lintRoot, diagnosticPath);
   }
   #createLintMessage(diagnostic) {
     const start = diagnostic.location?.start;
@@ -1379,14 +1493,7 @@ class Linter {
       if (diagnostic.severity !== "error" && diagnostic.severity !== "warning")
         continue;
       const diagnosticFilePath = this.#diagnosticFilePath(diagnostic, filePath);
-      const result = resultsByPath.get(diagnosticFilePath) ?? {
-        filePath: diagnosticFilePath,
-        messages: [],
-        errorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-      };
+      const result = resultsByPath.get(diagnosticFilePath) ?? emptyResult(diagnosticFilePath);
       const message = this.#createLintMessage(diagnostic);
       result.messages.push(message);
       if (message.severity === 2)
@@ -1396,14 +1503,7 @@ class Linter {
       resultsByPath.set(diagnosticFilePath, result);
     }
     return [
-      resultsByPath.get(filePath) ?? {
-        filePath,
-        messages: [],
-        errorCount: 0,
-        warningCount: 0,
-        fixableErrorCount: 0,
-        fixableWarningCount: 0
-      },
+      resultsByPath.get(filePath) ?? emptyResult(filePath),
       ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result)
     ];
   }
@@ -1513,12 +1613,7 @@ ${errorText}, ${warningText} found`];
       warningCount: acc.warningCount + result.warningCount,
       fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
       fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
-    }), {
-      errorCount: 0,
-      warningCount: 0,
-      fixableErrorCount: 0,
-      fixableWarningCount: 0
-    });
+    }), { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 });
     return { results, details, stats };
   }
   async hasNoLintErrors(filePath) {
@@ -1576,19 +1671,16 @@ ${errorText}, ${warningText} found`];
   async getProblematicRules(filePath) {
     const { results } = await this.lintFile(filePath);
     const ruleCounts = {};
-    results.forEach((result) => {
-      result.messages.forEach((message) => {
-        if (message.ruleId)
-          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
-      });
-    });
+    for (const message of results.flatMap((result) => result.messages))
+      if (message.ruleId)
+        ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
     return ruleCounts;
   }
 }
 
 // pkgs/@akanjs/devkit/repoIdentity.ts
 import { execFileSync } from "child_process";
-import path6 from "path";
+import path7 from "path";
 var resolved = new Map;
 var readRemoteName = (workspaceRoot) => {
   try {
@@ -1606,14 +1698,13 @@ var resolveRepoName = (workspaceRoot) => {
   const cached = resolved.get(workspaceRoot);
   if (cached)
     return cached;
-  const repoName = readRemoteName(workspaceRoot) ?? path6.basename(workspaceRoot);
+  const repoName = readRemoteName(workspaceRoot) ?? path7.basename(workspaceRoot);
   resolved.set(workspaceRoot, repoName);
   return repoName;
 };
 
 // pkgs/@akanjs/devkit/scanInfo.ts
-import { rm as rm2 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
 
 // pkgs/@akanjs/devkit/workspaceLayout.ts
 var appRootAllowedFiles = new Set([
@@ -1621,7 +1712,6 @@ var appRootAllowedFiles = new Set([
   "CLAUDE.md",
   "akan.app.json",
   "akan.config.ts",
-  "capacitor.config.ts",
   "client.ts",
   "main.ts",
   "package.json",
@@ -1631,12 +1721,10 @@ var appRootAllowedFiles = new Set([
 ]);
 var appRootAllowedDirs = new Set([
   ".akan",
-  "android",
   "common",
   "env",
-  "ios",
   "lib",
-  "mobile",
+  "native",
   "page",
   "plugin",
   "private",
@@ -1665,6 +1753,7 @@ var libRootAllowedDirs = new Set([
   "common",
   "env",
   "lib",
+  "native",
   "page",
   "plugin",
   "private",
@@ -1688,13 +1777,20 @@ var libFacetRootAllowedFiles = new Set([
 ]);
 var libFacetRootTestPattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
 var isAllowedLibFacetRootFile = (filename) => libFacetRootAllowedFiles.has(filename) || libFacetRootTestPattern.test(filename);
+var retiredAppRootEntries = new Set([
+  "android",
+  "ios",
+  "mobile",
+  "capacitor.config.ts",
+  "capacitor.config.js",
+  "capacitor.config.json"
+]);
+var rootEntryHintOf = (type, name) => type === "app" && retiredAppRootEntries.has(name) ? "a Capacitor-era entry; the native runtime generates its projects under .akan/native/<target>, so delete it" : null;
 var isScannedRootEntry = (type, name) => !name.startsWith(".") || rootAllowedDirs[type].has(name);
 
 // pkgs/@akanjs/devkit/scanInfo.ts
-var databaseFileTypes = [
-  "constant",
+var serviceFileTypes = [
   "dictionary",
-  "document",
   "service",
   "signal",
   "store",
@@ -1704,7 +1800,9 @@ var databaseFileTypes = [
   "view",
   "zone"
 ];
-var generatedRootCapacitorConfigFiles = ["capacitor.config.js", "capacitor.config.json"];
+var databaseFileTypes = ["constant", "dictionary", "document", ...serviceFileTypes.slice(1)];
+var uiFileTypes = new Set(["template", "unit", "util", "view", "zone"]);
+var fileTypeOf = (filename) => databaseFileTypes.find((type) => filename.endsWith(uiFileTypes.has(type) ? `.${type[0].toUpperCase()}${type.slice(1)}.tsx` : `.${type}.ts`));
 var internalLibDirs = new Set(["__lib", "__scalar"]);
 var moduleNonUiFileTypes = {
   database: new Set(["constant", "dictionary", "document", "service", "signal", "store"]),
@@ -1716,21 +1814,13 @@ var moduleUiFileTypes = {
   service: new Set(["Util", "Zone"]),
   scalar: new Set(["Template", "Unit"])
 };
-var testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
-var createDependencyScanner = async (exec) => (await import("./dependencyScanner-shs82ynp.js")).TypeScriptDependencyScanner.from(exec);
-var isAllowedTestFile = (filename) => testFilePattern.test(filename);
-var getScanPath = (exec, relativePath) => path7.posix.join(`${exec.type}s`, exec.name, relativePath.split(path7.sep).join("/"));
-async function clearGeneratedRootCapacitorConfigs(exec) {
-  if (exec.type !== "app")
-    return;
-  await Promise.all(generatedRootCapacitorConfigFiles.map((filename) => rm2(exec.getPath(filename), { force: true })));
-}
+var createDependencyScanner = async (exec) => (await import("./dependencyScanner-06z2dmrr.js")).TypeScriptDependencyScanner.from(exec);
+var getScanPath = (exec, relativePath) => path8.posix.join(`${exec.type}s`, exec.name, relativePath.split(path8.sep).join("/"));
 var getModuleNameFromPath = (kind, modulePath) => {
-  const dirname = path7.basename(modulePath);
+  const dirname = path8.basename(modulePath);
   return kind === "service" ? dirname.replace(/^_+/, "") : dirname;
 };
 async function assertScanConvention(exec, libRoot) {
-  await clearGeneratedRootCapacitorConfigs(exec);
   const violations = [];
   const addViolation = (relativePath, reason) => {
     violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
@@ -1738,28 +1828,28 @@ async function assertScanConvention(exec, libRoot) {
   const allowedRootFiles = rootAllowedFiles[exec.type];
   const allowedRootDirs = rootAllowedDirs[exec.type];
   const { files, dirs } = await exec.getFilesAndDirs(".");
-  files.filter((filename) => !allowedRootFiles.has(filename)).forEach((filename) => {
-    addViolation(filename, `unsupported ${exec.type} root file`);
-  });
-  dirs.filter((dirname) => !allowedRootDirs.has(dirname)).forEach((dirname) => {
-    addViolation(dirname, `unsupported ${exec.type} root folder`);
-  });
+  for (const filename of files)
+    if (!allowedRootFiles.has(filename))
+      addViolation(filename, rootEntryHintOf(exec.type, filename) ?? `unsupported ${exec.type} root file`);
+  for (const dirname of dirs)
+    if (!allowedRootDirs.has(dirname))
+      addViolation(dirname, rootEntryHintOf(exec.type, dirname) ?? `unsupported ${exec.type} root folder`);
   if (exec.type === "lib")
     for (const { relativePath, reason } of await exec.getPageConventionViolations())
       addViolation(relativePath, reason);
-  libRoot.files.filter((filename) => !isAllowedLibFacetRootFile(filename)).forEach((filename) => {
-    addViolation(path7.join("lib", filename), "unsupported lib facet root file");
-  });
-  libRoot.dirs.filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname)).forEach((dirname) => {
-    addViolation(path7.join("lib", dirname), "unsupported internal lib folder");
-  });
+  for (const filename of libRoot.files)
+    if (!isAllowedLibFacetRootFile(filename))
+      addViolation(path8.join("lib", filename), "unsupported lib facet root file");
+  for (const dirname of libRoot.dirs)
+    if (dirname.startsWith("__") && !internalLibDirs.has(dirname))
+      addViolation(path8.join("lib", dirname), "unsupported internal lib folder");
   const databaseDirs = libRoot.dirs.filter((dirname) => !dirname.startsWith("_"));
   const serviceDirs = libRoot.dirs.filter((dirname) => dirname.startsWith("_") && !dirname.startsWith("__"));
   const scalarDirs = await exec.readdir("lib/__scalar");
   await Promise.all([
-    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path7.join("lib", dirname))),
-    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path7.join("lib", dirname))),
-    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path7.join("lib/__scalar", dirname)))
+    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path8.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path8.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path8.join("lib/__scalar", dirname)))
   ]);
   if (violations.length > 0) {
     throw new Error(`[scan-convention]
@@ -1771,41 +1861,28 @@ 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, path7.join(modulePath, dirname))}: unsupported module folder`);
+    violations.push(`${getScanPath(exec, path8.join(modulePath, dirname))}: unsupported module folder`);
   });
   const uiModuleName = moduleName[0].toUpperCase() + moduleName.slice(1);
-  files.forEach((filename) => {
-    const filePath = path7.join(modulePath, filename);
-    if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
-      return;
+  for (const filename of files) {
+    const scanPath = getScanPath(exec, path8.join(modulePath, filename));
+    if (filename === "index.ts" || filename === "index.tsx" || /\.(test|spec)\.(ts|tsx)$/.test(filename))
+      continue;
     if (filename === `${moduleName}.abstract.md`)
-      return;
+      continue;
     const uiMatch = filename.match(/^([A-Z][A-Za-z0-9]+)\.([A-Z][A-Za-z0-9]*)\.tsx$/);
-    if (uiMatch) {
-      const fileModuleName = uiMatch[1];
-      const fileType = uiMatch[2];
-      if (fileModuleName !== uiModuleName) {
-        violations.push(`${getScanPath(exec, filePath)}: module name mismatch: expected '${uiModuleName}', got '${fileModuleName}'`);
-      }
-      if (!moduleUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} UI file`);
-      }
-      return;
-    }
-    const nonUiMatch = filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
-    if (nonUiMatch) {
-      const fileModuleName = nonUiMatch[1];
-      const fileType = nonUiMatch[2];
-      if (fileModuleName !== moduleName) {
-        violations.push(`${getScanPath(exec, filePath)}: module name mismatch: expected '${moduleName}', got '${fileModuleName}'`);
-      }
-      if (!moduleNonUiFileTypes[kind].has(fileType)) {
-        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} file`);
-      }
-      return;
+    const match = uiMatch ?? filename.match(/^([a-z][a-zA-Z0-9]*)\.([a-z][a-z0-9]*)\.ts$/);
+    if (!match) {
+      violations.push(`${scanPath}: unsupported module file`);
+      continue;
     }
-    violations.push(`${getScanPath(exec, filePath)}: unsupported module file`);
-  });
+    const [, fileModuleName, fileType] = match;
+    const expectedName = uiMatch ? uiModuleName : moduleName;
+    if (fileModuleName !== expectedName)
+      violations.push(`${scanPath}: module name mismatch: expected '${expectedName}', got '${fileModuleName}'`);
+    if (!(uiMatch ? moduleUiFileTypes : moduleNonUiFileTypes)[kind].has(fileType))
+      violations.push(`${scanPath}: unsupported ${kind}${uiMatch ? " UI" : ""} file`);
+  }
 }
 
 class ScanInfo {
@@ -1853,86 +1930,24 @@ class ScanInfo {
       } else
         databaseDirs.push(name);
     });
+    const collect = async (dir, name, kind) => {
+      for (const filename of await exec.readdir(dir)) {
+        const type = fileTypeOf(filename);
+        if (type)
+          files[type][kind]?.push(name);
+      }
+    };
     await Promise.all([
-      ...databaseDirs.map(async (name) => {
-        const filenames = await exec.readdir(path7.join("lib", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.databases.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.databases.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.databases.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.databases.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.databases.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.databases.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.databases.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.databases.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.databases.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.databases.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.databases.push(name);
-        });
-      }),
-      ...serviceDirs.map(async (dirname) => {
-        const name = dirname.slice(1);
-        const filenames = await exec.readdir(path7.join("lib", dirname));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.services.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.service.services.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.services.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.services.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.services.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.services.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.services.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.services.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.services.push(name);
-        });
-      }),
-      ...scalarDirs.map(async (name) => {
-        const filenames = await exec.readdir(path7.join("lib/__scalar", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constant.scalars.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.scalars.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.document.scalars.push(name);
-          else if (filename.endsWith(".Template.tsx"))
-            files.template.scalars.push(name);
-          else if (filename.endsWith(".Unit.tsx"))
-            files.unit.scalars.push(name);
-          else if (filename.endsWith(".Util.tsx"))
-            files.util.scalars.push(name);
-          else if (filename.endsWith(".View.tsx"))
-            files.view.scalars.push(name);
-          else if (filename.endsWith(".Zone.tsx"))
-            files.zone.scalars.push(name);
-        });
-      })
+      ...databaseDirs.map((name) => collect(path8.join("lib", name), name, "databases")),
+      ...serviceDirs.map((dirname) => collect(path8.join("lib", dirname), dirname.slice(1), "services")),
+      ...scalarDirs.map((name) => collect(path8.join("lib/__scalar", name), name, "scalars"))
     ]);
     const routes = exec.type === "lib" ? [] : await exec.getPageKeys();
     const common = {
       name: exec.name,
       type: exec.type,
       repoName: exec.workspace.repoName,
-      serveDomain: WorkspaceExecutor.getBaseDevEnv(path7.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
+      serveDomain: WorkspaceExecutor.getBaseDevEnv(path8.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
       files,
       libDeps,
       pkgDeps,
@@ -1946,31 +1961,14 @@ class ScanInfo {
   constructor(scanResult) {
     this.name = scanResult.name;
     this.scanResult = scanResult;
-    Object.entries(scanResult.files).forEach(([_key, value]) => {
-      const key = _key;
-      const { databases, services, scalars } = value;
-      databases.forEach((modelName) => {
-        const model = this.database.get(modelName) ?? new Set;
-        model.add(key);
-        this.database.set(modelName, model);
-        this.file[key].all.add(modelName);
-        this.file[key].databases.add(modelName);
-      });
-      services?.forEach((serviceName) => {
-        const service = this.service.get(serviceName) ?? new Set;
-        service.add(key);
-        this.service.set(serviceName, service);
-        this.file[key].all.add(serviceName);
-        this.file[key].services.add(serviceName);
-      });
-      scalars?.forEach((scalarName) => {
-        const scalar = this.scalar.get(scalarName) ?? new Set;
-        scalar.add(key);
-        this.scalar.set(scalarName, scalar);
-        this.file[key].all.add(scalarName);
-        this.file[key].scalars.add(scalarName);
-      });
-    });
+    const modulesOf = { databases: this.database, services: this.service, scalars: this.scalar };
+    for (const [key, groups] of Object.entries(scanResult.files))
+      for (const kind of ["databases", "services", "scalars"])
+        for (const name of groups[kind] ?? []) {
+          modulesOf[kind].set(name, (modulesOf[kind].get(name) ?? new Set).add(key));
+          this.file[key].all.add(name);
+          this.file[key][kind].add(name);
+        }
   }
   getScanResult() {
     return this.scanResult;
@@ -1984,6 +1982,28 @@ class ScanInfo {
   getScalarModules() {
     return [...this.scalar.keys()];
   }
+  #sortedLibs = null;
+  sortedLibs(libDeps) {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = libDeps.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === undefined || indexB === undefined)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  sortedLibInfos(libDeps) {
+    return new Map(this.sortedLibs(libDeps).map((libName) => {
+      const libInfo = LibInfo.libInfos.get(libName);
+      if (!libInfo)
+        throw new Error(`LibInfo not found: ${libName}`);
+      return [libName, libInfo];
+    }));
+  }
 }
 var isAkanFrameworkDependency = (dep) => dep === "akanjs" || dep.startsWith("akanjs/");
 
@@ -2033,30 +2053,11 @@ class AppInfo extends ScanInfo {
     }));
     return [...libSet];
   }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libIndices = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libIndices.get(libNameA);
-      const indexB = libIndices.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.libDeps);
   }
   getLibInfos() {
-    return new Map(this.#getSortedLibs().map((libName) => {
-      const libInfo = LibInfo.libInfos.get(libName);
-      if (!libInfo)
-        throw new Error(`LibInfo not found: ${libName}`);
-      return [libName, libInfo];
-    }));
+    return this.sortedLibInfos(this.libDeps);
   }
 }
 
@@ -2096,38 +2097,18 @@ class LibInfo extends ScanInfo {
   getScanResult() {
     return this.scanResult;
   }
-  #sortedLibs = null;
-  #getSortedLibs() {
-    if (this.#sortedLibs)
-      return this.#sortedLibs;
-    const libs = LibInfo.getSortedLibIndices();
-    this.#sortedLibs = this.scanResult.libDeps.sort((libNameA, libNameB) => {
-      const indexA = libs.get(libNameA);
-      const indexB = libs.get(libNameB);
-      if (indexA === undefined || indexB === undefined)
-        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
-      return indexA - indexB;
-    });
-    return this.#sortedLibs;
-  }
   getLibs() {
-    return this.#getSortedLibs();
+    return this.sortedLibs(this.scanResult.libDeps);
   }
   getLibInfo(libName) {
     if (!this.getScanResult().libDeps.includes(libName))
       return;
-    const libSet = new Set(this.#getSortedLibs());
-    if (!libSet.has(libName))
+    if (!this.getLibs().includes(libName))
       throw new Error(`LibInfo is invalid: ${libName}`);
     return LibInfo.libInfos.get(libName);
   }
   getLibInfos() {
-    return new Map(this.#getSortedLibs().map((libName) => {
-      const libInfo = LibInfo.libInfos.get(libName);
-      if (!libInfo)
-        throw new Error(`LibInfo not found: ${libName}`);
-      return [libName, libInfo];
-    }));
+    return this.sortedLibInfos(this.scanResult.libDeps);
   }
 }
 
@@ -2139,18 +2120,14 @@ class PkgInfo {
     const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
     const scanner = await createDependencyScanner(exec);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
-    const pkgPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path) => path.replace("/*", "")));
+    const workspacePathOf = (resolve) => resolve.replace(/^\.\//, "");
+    const pkgPathSet = new Set(Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => workspacePathOf(resolve).startsWith("pkgs/"))).map((path) => path.replace("/*", "")));
     const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
     const pkgDeps = [...pkgPathDepSet].map((path) => {
       const pathSplitLength = path.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+      return workspacePathOf(tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
     }).filter((pkg) => pkg !== exec.name);
-    const pkgScanResult = {
-      name: exec.name,
-      pkgDeps,
-      dependencies: [...npmDepSet]
-    };
-    return pkgScanResult;
+    return { name: exec.name, pkgDeps, dependencies: [...npmDepSet] };
   }
   static #pkgInfos = new Map;
   static async fromExecutor(exec, options = {}) {
@@ -2188,17 +2165,9 @@ class WorkspaceInfo {
       return existingWorkspaceInfo;
     const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
     const [appInfos, libInfos, pkgInfos] = await Promise.all([
-      Promise.all(appNames.map(async (appName) => {
-        const app = AppExecutor.from(exec, appName);
-        return await app.scan();
-      })),
-      Promise.all(libNames.map(async (libName) => {
-        const lib = LibExecutor.from(exec, libName);
-        return await lib.scan();
-      })),
-      Promise.all(pkgNames.map(async (pkgName) => {
-        return await PkgExecutor.from(exec, pkgName).scan();
-      }))
+      Promise.all(appNames.map(async (appName) => await AppExecutor.from(exec, appName).scan())),
+      Promise.all(libNames.map(async (libName) => await LibExecutor.from(exec, libName).scan())),
+      Promise.all(pkgNames.map(async (pkgName) => await PkgExecutor.from(exec, pkgName).scan()))
     ]);
     const workspaceInfo = new WorkspaceInfo(new Map(appInfos.map((app) => [app.exec.name, app])), new Map(libInfos.map((lib) => [lib.exec.name, lib])), new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg])));
     WorkspaceInfo.#workspaceInfos.set(exec.name, workspaceInfo);
@@ -2207,40 +2176,9 @@ class WorkspaceInfo {
 }
 
 // pkgs/@akanjs/devkit/executors.ts
-var staticTemplateFileExtensions = new Set([
-  ".avif",
-  ".bmp",
-  ".cjs",
-  ".css",
-  ".eot",
-  ".gif",
-  ".html",
-  ".ico",
-  ".jpeg",
-  ".jpg",
-  ".js",
-  ".json",
-  ".map",
-  ".md",
-  ".mjs",
-  ".mp3",
-  ".mp4",
-  ".ogg",
-  ".otf",
-  ".pdf",
-  ".png",
-  ".svg",
-  ".ttf",
-  ".txt",
-  ".wasm",
-  ".wav",
-  ".webm",
-  ".webp",
-  ".woff",
-  ".woff2",
-  ".xml"
-]);
-var formatCommandArg = (value) => /^[\w@%+=:,./-]+$/.test(value) ? value : JSON.stringify(value);
+var staticTemplateFileExtensions = new Set(".avif .bmp .cjs .css .eot .gif .html .ico .jpeg .jpg .js .json .map .md .mjs .mp3 .mp4 .ogg .otf .pdf .png .svg".split(" ").concat(".ttf .txt .wasm .wav .webm .webp .woff .woff2 .xml".split(" ")));
+var plainCommandArgPattern = process.platform === "win32" ? /^[\w@%+=:,./\\-]+$/ : /^[\w@%+=:,./-]+$/;
+var formatCommandArg = (value) => plainCommandArgPattern.test(value) ? value : JSON.stringify(value);
 var formatCommandForDisplay = (command, args = []) => [command, ...args].map(formatCommandArg).join(" ");
 
 class CommandExecutionError extends Error {
@@ -2314,6 +2252,10 @@ var parseEnvFile = (envPath) => {
   }
   return env;
 };
+var withCapitalizedDict = (dict = {}) => ({
+  ...dict,
+  ...Object.fromEntries(Object.entries(dict).map(([key, value]) => [capitalize(key), capitalize(value)]))
+});
 
 class Executor {
   static verbose = false;
@@ -2340,150 +2282,57 @@ class Executor {
   #stderr(data) {
     Logger2.raw(chalk2.red(data.toString()));
   }
-  exec(command, options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = exec(command, { cwd: this.cwdPath, ...options });
+  #settle(proc, target, { onClose = false, keepLogs = false, redStderr = false } = {}) {
     let stdout = "";
     let stderr = "";
     proc.stdout?.on("data", (data) => {
       stdout += data.toString();
+      if (keepLogs)
+        this.logs.push(data.toString());
       this.#stdout(data);
     });
     proc.stderr?.on("data", (data) => {
       stderr += data.toString();
-      this.#stdout(data);
+      if (keepLogs)
+        this.logs.push(data.toString());
+      if (redStderr)
+        this.#stderr(data);
+      else
+        this.#stdout(data);
     });
     return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("exit", (code, signal) => {
-        if (code || signal)
-          reject(new CommandExecutionError({
-            command,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
+      proc.on("error", (cause) => reject(new CommandExecutionError({ ...target, code: null, signal: null, stdout, stderr, cause })));
+      proc.on(onClose ? "close" : "exit", (code, signal) => {
+        if ((onClose ? code !== 0 : code) || signal)
+          reject(new CommandExecutionError({ ...target, code, signal, stdout, stderr }));
         else
-          resolve({ code, signal });
+          resolve({ code, signal, stdout });
       });
     });
   }
+  exec(command, options = {}) {
+    const target = { command, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = exec(command, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target).then(({ code, signal }) => ({ code, signal }));
+  }
   spawn(command, args = [], options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = spawn2(command, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      this.logs.push(data.toString());
-      this.#stdout(data);
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-      this.logs.push(data.toString());
-      this.#stdout(data);
-    });
-    return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command,
-          args,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("close", (code, signal) => {
-        if (code !== 0 || signal)
-          reject(new CommandExecutionError({
-            command,
-            args,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
-        else
-          resolve(stdout);
-      });
-    });
+    const target = { command, args, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = spawn2(command, args, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target, { onClose: true, keepLogs: true }).then(({ stdout }) => stdout);
   }
   spawnSync(command, args = [], options = {}) {
-    const proc = spawn2(command, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    return proc;
+    return spawn2(command, args, { cwd: this.cwdPath, ...options });
   }
   fork(modulePath, args = [], options = {}) {
-    const cwd = options.cwd?.toString() ?? this.cwdPath;
-    const proc = fork(modulePath, args, {
-      cwd: this.cwdPath,
-      ...options
-    });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout?.on("data", (data) => {
-      stdout += data.toString();
-      this.#stdout(data);
-    });
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-      this.#stderr(data);
-    });
-    return new Promise((resolve, reject) => {
-      proc.on("error", (error) => {
-        reject(new CommandExecutionError({
-          command: modulePath,
-          args,
-          cwd,
-          code: null,
-          signal: null,
-          stdout,
-          stderr,
-          cause: error
-        }));
-      });
-      proc.on("exit", (code, signal) => {
-        if (code || signal)
-          reject(new CommandExecutionError({
-            command: modulePath,
-            args,
-            cwd,
-            code,
-            signal,
-            stdout,
-            stderr
-          }));
-        else
-          resolve({ code, signal });
-      });
-    });
+    const target = { command: modulePath, args, cwd: options.cwd?.toString() ?? this.cwdPath };
+    const proc = fork(modulePath, args, { cwd: this.cwdPath, ...options });
+    return this.#settle(proc, target, { redStderr: true }).then(({ code, signal }) => ({ code, signal }));
   }
   getPath(filePath) {
-    if (path8.isAbsolute(filePath))
+    if (path9.isAbsolute(filePath))
       return filePath;
     if (filePath.startsWith("."))
-      return path8.join(this.cwdPath, filePath);
+      return path9.join(this.cwdPath, filePath);
     const baseParts = this.cwdPath.split(/[\\/]/).filter(Boolean);
     const targetParts = filePath.split(/[\\/]/).filter(Boolean);
     let overlapLength = 0;
@@ -2497,12 +2346,12 @@ class Executor {
       if (isOverlap)
         overlapLength = i;
     }
-    return path8.join(this.cwdPath, ...targetParts.slice(overlapLength));
+    return path9.join(this.cwdPath, ...targetParts.slice(overlapLength));
   }
   async mkdir(dirPath) {
     const writePath = this.getPath(dirPath);
-    if (!await FileSys.dirExists(writePath))
-      await mkdir3(writePath, { recursive: true });
+    if (!await FileSys2.dirExists(writePath))
+      await mkdir2(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
@@ -2521,50 +2370,48 @@ class Executor {
   }
   async getFilesAndDirs(dirPath) {
     const fullDirPath = this.getPath(dirPath);
-    const fileGlob = new Bun.Glob("*");
-    const files = Array.from(fileGlob.scanSync({ cwd: fullDirPath, onlyFiles: true }));
-    const dirGlob = new Bun.Glob("*");
-    const allEntries = Array.from(dirGlob.scanSync({ cwd: fullDirPath, onlyFiles: false }));
+    const glob = new Bun.Glob("*");
+    const files = Array.from(glob.scanSync({ cwd: fullDirPath, onlyFiles: true }));
+    const allEntries = Array.from(glob.scanSync({ cwd: fullDirPath, onlyFiles: false }));
     const dirs = allEntries.filter((entry) => !files.includes(entry));
     return { files, dirs };
   }
   async exists(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.exists(readPath);
+    return await FileSys2.exists(this.getPath(filePath));
   }
   async remove(filePath) {
     const readPath = this.getPath(filePath);
-    if (await FileSys.fileExists(readPath))
-      await FileSys.delete(readPath);
+    if (await FileSys2.fileExists(readPath))
+      await FileSys2.delete(readPath);
     this.logger.verbose(`Remove file ${readPath}`);
     return this;
   }
   async removeDir(dirPath) {
-    const readPath = path8.join(this.getPath(dirPath), ".");
-    if (await FileSys.entryExists(readPath))
+    const readPath = path9.join(this.getPath(dirPath), ".");
+    if (await FileSys2.entryExists(readPath))
       await rm3(readPath, { recursive: true, force: true });
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
   }
   async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
     const writePath = this.getPath(filePath);
-    const dir = path8.dirname(writePath);
-    if (!await FileSys.dirExists(dir))
-      await mkdir3(dir, { recursive: true });
+    const dir = path9.dirname(writePath);
+    if (!await FileSys2.dirExists(dir))
+      await mkdir2(dir, { recursive: true });
     let contentStr = typeof content === "string" ? content : `${JSON.stringify(content, null, 2)}
 `;
-    if (await FileSys.fileExists(writePath)) {
-      const currentContent = await FileSys.readText(writePath);
+    if (await FileSys2.fileExists(writePath)) {
+      const currentContent = await FileSys2.readText(writePath);
       if (currentContent === contentStr || !overwrite) {
         this.logger.verbose(`File ${writePath} is unchanged`);
         contentStr = currentContent;
       } else {
-        await FileSys.writeText(writePath, contentStr);
+        await FileSys2.writeText(writePath, contentStr);
         if (Logger2.isVerbose())
           this.logger.rawLog(chalk2.yellow(`File Update: ${filePath}`));
       }
     } else {
-      await FileSys.writeText(writePath, contentStr);
+      await FileSys2.writeText(writePath, contentStr);
       if (!silent)
         this.logger.rawLog(chalk2.green(`File Create: ${filePath}`));
     }
@@ -2574,27 +2421,25 @@ class Executor {
     await this.writeFile(filePath, content);
   }
   async getLocalFile(targetPath) {
-    const filePath = path8.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const filePath = path9.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
     const content = await this.readFile(filePath);
     return { filePath, content };
   }
   async readFile(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.readText(readPath);
+    return await FileSys2.readText(this.getPath(filePath));
   }
   async readJson(filePath) {
-    const readPath = this.getPath(filePath);
-    return await FileSys.readJson(readPath);
+    return await FileSys2.readJson(this.getPath(filePath));
   }
   async cp(srcPath, destPath, { dereference = false } = {}) {
     const src = this.getPath(srcPath);
     const dest = this.getPath(destPath);
-    if (!await FileSys.exists(src))
+    if (!await FileSys2.exists(src))
       return;
     const isDirectory = (await stat2(src)).isDirectory();
-    if (!await FileSys.exists(dest) && isDirectory)
-      await mkdir3(dest, { recursive: true });
-    if (dereference)
+    if (!await FileSys2.exists(dest) && isDirectory)
+      await mkdir2(dest, { recursive: true });
+    if (dereference || process.platform === "win32")
       await cpEntry(src, dest, { recursive: isDirectory, dereference: true, force: true });
     else
       await $`cp -r ${src}${isDirectory ? "/." : ""} ${dest}`;
@@ -2618,19 +2463,10 @@ class Executor {
   async getTsConfig(pathname = "tsconfig.json", { refresh } = {}) {
     if (this.#tsconfig && !refresh)
       return this.#tsconfig;
-    const tsconfig = await this.readJson(pathname);
+    let tsconfig = await this.readJson(pathname);
     if (tsconfig.extends) {
-      const extendsTsconfig = await this.getTsConfig(tsconfig.extends);
-      const result = {
-        ...extendsTsconfig,
-        ...tsconfig,
-        compilerOptions: {
-          ...extendsTsconfig.compilerOptions,
-          ...tsconfig.compilerOptions
-        }
-      };
-      this.#tsconfig = result;
-      return result;
+      const base = await this.getTsConfig(tsconfig.extends, { refresh });
+      tsconfig = { ...base, ...tsconfig, compilerOptions: { ...base.compilerOptions, ...tsconfig.compilerOptions } };
     }
     this.#tsconfig = tsconfig;
     return tsconfig;
@@ -2666,31 +2502,29 @@ class Executor {
     scanInfo,
     overwrite = true
   }, dict = {}, options = {}) {
+    const convertPath = (target) => Object.entries(dict).reduce((converted, [key, value]) => converted.replace(new RegExp(`__${key}__`, "g"), value), target);
     if (targetPath.endsWith(".ts") || targetPath.endsWith(".tsx")) {
       const getContent = await import(templatePath);
       const result = await getContent.default(scanInfo ?? null, dict, options);
       if (result === null)
         return null;
-      const filename = typeof result === "object" ? result.filename : path8.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : path9.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname = path8.dirname(targetPath);
-      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), `${dirname}/${filename}`);
+      const convertedTargetPath = convertPath(`${path9.dirname(targetPath)}/${filename}`);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return this.writeFile(convertedTargetPath, content, { overwrite });
     } else if (targetPath.endsWith(".template")) {
-      const content = await FileSys.readText(templatePath);
-      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), targetPath.slice(0, -9));
+      const content = await FileSys2.readText(templatePath);
+      const convertedTargetPath = convertPath(targetPath.slice(0, -9));
       const convertedContent = Object.entries(dict).reduce((data, [key, value]) => data.replace(new RegExp(`<%= ${key} %>`, "g"), value), content);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
-      return this.writeFile(convertedTargetPath, convertedContent, {
-        overwrite
-      });
-    } else if (staticTemplateFileExtensions.has(path8.extname(targetPath).toLowerCase())) {
-      const convertedTargetPath = Object.entries(dict).reduce((path, [key, value]) => path.replace(new RegExp(`__${key}__`, "g"), value), targetPath);
+      return this.writeFile(convertedTargetPath, convertedContent, { overwrite });
+    } else if (staticTemplateFileExtensions.has(path9.extname(targetPath).toLowerCase())) {
+      const convertedTargetPath = convertPath(targetPath);
       const writePath = this.getPath(convertedTargetPath);
-      const dirname = path8.dirname(writePath);
-      if (!await FileSys.dirExists(dirname))
-        await mkdir3(dirname, { recursive: true });
+      const dirname = path9.dirname(writePath);
+      if (!await FileSys2.dirExists(dirname))
+        await mkdir2(dirname, { recursive: true });
       await copyFile(templatePath, writePath);
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       return { filePath: writePath, content: "" };
@@ -2707,12 +2541,10 @@ class Executor {
   }) {
     const templateRoot = await this.#resolveTemplateRoot();
     const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
-    const prefixTemplatePath = templatePath;
-    if ((await stat2(prefixTemplatePath)).isFile()) {
-      const filename = path8.basename(prefixTemplatePath);
+    if ((await stat2(templatePath)).isFile()) {
       const fileContent = await this.#applyTemplateFile({
-        templatePath: prefixTemplatePath,
-        targetPath: path8.join(basePath, filename),
+        templatePath,
+        targetPath: path9.join(basePath, path9.basename(templatePath)),
         scanInfo,
         overwrite
       }, dict, options);
@@ -2720,19 +2552,19 @@ class Executor {
     } else {
       const subdirs = await readDirEntries(templatePath);
       const fileContents = (await Promise.all(subdirs.map(async (subdir) => {
-        const subpath = path8.join(templatePath, subdir);
+        const subpath = path9.join(templatePath, subdir);
         if ((await stat2(subpath)).isFile()) {
           const fileContent = await this.#applyTemplateFile({
             templatePath: subpath,
-            targetPath: path8.join(basePath, subdir),
+            targetPath: path9.join(basePath, subdir),
             scanInfo,
             overwrite
           }, dict, options);
           return fileContent ? [fileContent] : [];
         } else
           return await this._applyTemplate({
-            basePath: path8.join(basePath, subdir),
-            template: path8.join(template, subdir),
+            basePath: path9.join(basePath, subdir),
+            template: path9.join(template, subdir),
             scanInfo,
             dict,
             overwrite,
@@ -2744,21 +2576,17 @@ class Executor {
   }
   async#resolveTemplateRoot() {
     const candidates = [
-      path8.resolve(getDirname2(import.meta.url), "templates"),
-      path8.resolve(getDirname2(import.meta.url), "../cli/templates")
+      path9.resolve(getDirname2(import.meta.url), "templates"),
+      path9.resolve(getDirname2(import.meta.url), "../cli/templates")
     ];
     for (const candidate of candidates) {
-      if (await FileSys.dirExists(candidate))
+      if (await FileSys2.dirExists(candidate))
         return candidate;
     }
     return candidates[0];
   }
   async applyTemplate(options) {
-    const dict = {
-      ...options.dict ?? {},
-      ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
-    };
-    const fileContents = await this._applyTemplate({ ...options, dict });
+    const fileContents = await this._applyTemplate({ ...options, dict: withCapitalizedDict(options.dict) });
     await this.#formatAppliedTemplate(fileContents);
     return fileContents;
   }
@@ -2775,7 +2603,7 @@ class Executor {
     }
   }
   async getTypeChecker() {
-    const { TypeChecker } = await import("./typeChecker-3xgrzc2v.js");
+    const { TypeChecker } = await import("./typeChecker-px49mezc.js");
     this.typeChecker ??= new TypeChecker(this);
     return this.typeChecker;
   }
@@ -2817,11 +2645,11 @@ class Executor {
   async#resolveTypecheckWorkerEntry() {
     const dirname = getDirname2(import.meta.url);
     const candidates = [
-      path8.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path8.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
-      path8.join(dirname, "typecheck/typecheck.proc.ts"),
-      path8.join(dirname, "typecheck.proc.js"),
-      path8.join(dirname, "typecheck.proc.ts")
+      path9.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path9.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path9.join(dirname, "typecheck/typecheck.proc.ts"),
+      path9.join(dirname, "typecheck.proc.js"),
+      path9.join(dirname, "typecheck.proc.ts")
     ];
     for (const candidate of candidates)
       if (await Bun.file(candidate).exists())
@@ -2853,12 +2681,11 @@ class WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static #execs = new Map;
   static fromRoot({
     workspaceRoot = process.cwd(),
     repoName = resolveRepoName(workspaceRoot)
   } = {}) {
-    return WorkspaceExecutor.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
+    return new WorkspaceExecutor({ workspaceRoot, repoName });
   }
   static getBaseDevEnv(envPath) {
     const sourceEnv = envPath ? { ...process.env, ...parseEnvFile(envPath) } : process.env;
@@ -2897,13 +2724,9 @@ class WorkspaceExecutor extends Executor {
     return await WorkspaceInfo.fromExecutor(this);
   }
   async getApps() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/apps`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/apps`, "akan.config.ts");
   }
   async getLibs() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/libs`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/libs`, "akan.config.ts");
   }
   async getSyss() {
@@ -2911,8 +2734,6 @@ class WorkspaceExecutor extends Executor {
     return [appNames, libNames];
   }
   async getPkgs() {
-    if (!await FileSys.dirExists(`${this.workspaceRoot}/pkgs`))
-      return [];
     return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
   }
   async getExecs() {
@@ -2948,7 +2769,7 @@ class WorkspaceExecutor extends Executor {
       await Promise.all(dirs.map(async (dir) => {
         if (dir.includes("_") || AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path8.join(dirname, dir);
+        const dirPath = path9.join(dirname, dir);
         if ((await stat2(dirPath)).isDirectory()) {
           results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2977,15 +2798,17 @@ class WorkspaceExecutor extends Executor {
     return stdout.split("\x00").filter((file) => !!file).sort();
   }
   async#getDirHasFile(basePath, targetFilename) {
-    const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
+    if (!await FileSys2.dirExists(basePath))
+      return [];
+    const AVOID_DIRS = ["node_modules", "dist", "public", "webkit", "local"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
       const dirs = await this.readdir(dirname);
       await Promise.all(dirs.map(async (dir) => {
         if (AVOID_DIRS.includes(dir))
           return;
-        const dirPath = path8.join(dirname, dir);
-        if (await FileSys.dirExists(dirPath)) {
-          const hasTargetFile = await FileSys.fileExists(path8.join(dirPath, targetFilename));
+        const dirPath = path9.join(dirname, dir);
+        if (await FileSys2.dirExists(dirPath)) {
+          const hasTargetFile = await FileSys2.fileExists(path9.join(dirPath, targetFilename));
           if (hasTargetFile)
             results.push(`${prefix}${dir}`);
           if (maxDepth > 0)
@@ -2994,39 +2817,25 @@ class WorkspaceExecutor extends Executor {
       }));
       return results;
     };
-    return await getDirs(basePath);
+    return (await getDirs(basePath)).sort((a, b) => a.localeCompare(b));
   }
-  async getScalarConstantFiles() {
+  async#fromEverySys(read) {
     const [appNames, libNames] = await this.getSyss();
-    const scalarConstantExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getScalarConstantFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getScalarConstantFiles()))).flat()
-    ];
-    return scalarConstantExampleFiles;
+    const fromApps = await Promise.all(appNames.map((appName) => read(AppExecutor.from(this, appName))));
+    const fromLibs = await Promise.all(libNames.map((libName) => read(LibExecutor.from(this, libName))));
+    return [...fromApps.flat(), ...fromLibs.flat()];
+  }
+  async getScalarConstantFiles() {
+    return await this.#fromEverySys((sys) => sys.getScalarConstantFiles());
   }
   async getConstantFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const moduleConstantExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getConstantFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getConstantFiles()))).flat()
-    ];
-    return moduleConstantExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getConstantFiles());
   }
   async getDictionaryFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const moduleDictionaryExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getDictionaryFiles()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getDictionaryFiles()))).flat()
-    ];
-    return moduleDictionaryExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getDictionaryFiles());
   }
   async getViewFiles() {
-    const [appNames, libNames] = await this.getSyss();
-    const viewExampleFiles = [
-      ...(await Promise.all(appNames.map((appName) => AppExecutor.from(this, appName).getViewsSourceCode()))).flat(),
-      ...(await Promise.all(libNames.map((libName) => LibExecutor.from(this, libName).getViewsSourceCode()))).flat()
-    ];
-    return viewExampleFiles;
+    return await this.#fromEverySys((sys) => sys.getViewsSourceCode());
   }
 }
 var scanFacetDirs = ["ui", "webkit", "srvkit", "common", "plugin"];
@@ -3059,7 +2868,7 @@ class SysExecutor extends Executor {
       return [];
     const violations = [];
     for (const entry of await this.getAllFiles("**/*", { cwd: this.getPath("page") })) {
-      const relativePath = entry.split(path8.sep).join("/");
+      const relativePath = entry.split(path9.sep).join("/");
       const reason = getPageSourceFileViolation(relativePath);
       if (reason)
         violations.push({ relativePath: `page/${relativePath}`, reason });
@@ -3090,24 +2899,11 @@ class SysExecutor extends Executor {
         scanInfo,
         options: { exec: this, facet }
       })),
-      ...scanInfo.getDatabaseModules().map((model) => this._applyTemplate({
-        basePath: `lib/${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      })),
-      ...scanInfo.getServiceModules().map((model) => this._applyTemplate({
-        basePath: `lib/_${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      })),
-      ...scanInfo.getScalarModules().map((model) => this._applyTemplate({
-        basePath: `lib/__scalar/${model}`,
-        template: "moduleRoot",
-        scanInfo,
-        dict: { model, Model: capitalize(model) }
-      }))
+      ...[
+        ...scanInfo.getDatabaseModules().map((model) => [model, `lib/${model}`]),
+        ...scanInfo.getServiceModules().map((model) => [model, `lib/_${model}`]),
+        ...scanInfo.getScalarModules().map((model) => [model, `lib/__scalar/${model}`])
+      ].map(([model, basePath]) => this._applyTemplate({ basePath, template: "moduleRoot", scanInfo, dict: { model, Model: capitalize(model) } }))
     ];
   }
   async scan({
@@ -3169,45 +2965,43 @@ class SysExecutor extends Executor {
     await this.setPackageJson(libPkgJsonWithDeps);
   }
   async getLocalFile(targetPath) {
-    const filePath = path8.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const filePath = path9.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
     const content = await this.workspace.readFile(filePath);
     return { filePath, content };
   }
   async getDatabaseModules() {
-    const databaseModules = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.constant.ts`).exists());
-    return databaseModules;
+    return (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.endsWith(".ts")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
   }
   async getServiceModules() {
-    const serviceModules = (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.service.ts`).exists());
-    return serviceModules;
+    return (await this.readdir("lib")).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${name.slice(1)}.service.ts`));
   }
   async getScalarModules() {
-    const scalarModules = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => Bun.file(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`).exists());
-    return scalarModules;
+    return (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_")).filter((name) => existsSync2(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+  }
+  async#getComponentModules(role) {
+    return (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.endsWith(".ts")).filter((name) => existsSync2(`${this.cwdPath}/lib/${name}/${capitalize(name)}.${role}.tsx`));
+  }
+  async#getComponentSources(role) {
+    const modules = await this.#getComponentModules(role);
+    return Promise.all(modules.map((name) => this.getLocalFile(`lib/${name}/${capitalize(name)}.${role}.tsx`)));
   }
   async getViewComponents() {
-    const viewComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
-    return viewComponents;
+    return await this.#getComponentModules("View");
   }
   async getUnitComponents() {
-    const unitComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
-    return unitComponents;
+    return await this.#getComponentModules("Unit");
   }
   async getTemplateComponents() {
-    const templateComponents = (await this.readdir("lib")).filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts")).filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
-    return templateComponents;
+    return await this.#getComponentModules("Template");
   }
   async getViewsSourceCode() {
-    const viewComponents = await this.getViewComponents();
-    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`)));
+    return await this.#getComponentSources("View");
   }
   async getUnitsSourceCode() {
-    const unitComponents = await this.getUnitComponents();
-    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`)));
+    return await this.#getComponentSources("Unit");
   }
   async getTemplatesSourceCode() {
-    const templateComponents = await this.getTemplateComponents();
-    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`)));
+    return await this.#getComponentSources("Template");
   }
   async getScalarConstantFiles() {
     const scalarModules = await this.getScalarModules();
@@ -3215,7 +3009,7 @@ class SysExecutor extends Executor {
   }
   async getScalarDictionaryFiles() {
     const scalarModules = await this.getScalarModules();
-    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/${scalarModule}/${scalarModule}.dictionary.ts`)));
+    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.dictionary.ts`)));
   }
   async getConstantFiles() {
     const modules = await this.getModules();
@@ -3237,16 +3031,8 @@ class SysExecutor extends Executor {
     return Promise.all(modules.map((module) => this.getLocalFile(`lib/${module}/${module}.dictionary.ts`)));
   }
   async applyTemplate(options) {
-    const dict = {
-      ...options.dict ?? {},
-      ...Object.fromEntries(Object.entries(options.dict ?? {}).map(([key, value]) => [capitalize(key), capitalize(value)]))
-    };
     const scanInfo = await this.scan();
-    const fileContents = await this._applyTemplate({
-      ...options,
-      scanInfo,
-      dict
-    });
+    const fileContents = await this._applyTemplate({ ...options, scanInfo, dict: withCapitalizedDict(options.dict) });
     await this.scan();
     return fileContents;
   }
@@ -3255,7 +3041,7 @@ class SysExecutor extends Executor {
 class AppExecutor extends SysExecutor {
   static #routeSourceValidator = null;
   static async#getRouteSourceValidator() {
-    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-apyqw7wk.js")).RouteSourceValidator;
+    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-7ycnfz0e.js")).RouteSourceValidator;
     return AppExecutor.#routeSourceValidator;
   }
   dist;
@@ -3264,15 +3050,20 @@ class AppExecutor extends SysExecutor {
     super({ workspace, name, type: "app" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/apps/${name}`);
   }
-  static #execs = new Map;
   static from(executor, name) {
-    const exec = AppExecutor.#execs.get(name);
-    if (exec)
-      return exec;
-    else if (executor instanceof WorkspaceExecutor)
-      return new AppExecutor({ workspace: executor, name });
-    else
-      return new AppExecutor({ workspace: executor.workspace, name });
+    return new AppExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
+  }
+  static #keptOnStart = [path9.join(".akan", "native"), path9.join(".akan", "cache", "bin")];
+  async#removeDevOutput(dir = ".akan") {
+    const entries = await readDirEntries(this.getPath(dir)).catch(() => []);
+    await Promise.all(entries.map(async (name) => {
+      const entry = path9.join(dir, name);
+      if (AppExecutor.#keptOnStart.includes(entry))
+        return;
+      if (AppExecutor.#keptOnStart.some((kept) => kept.startsWith(`${entry}${path9.sep}`)))
+        return await this.#removeDevOutput(entry);
+      await this.removeDir(entry);
+    }));
   }
   getEnv() {
     return WorkspaceExecutor.getBaseDevEnv().env;
@@ -3288,10 +3079,8 @@ class AppExecutor extends SysExecutor {
     return basePort + appIndex + portOffset;
   }
   getCommandEnv(env = {}) {
-    const basePort = 8282;
-    const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
-    const PORT = (basePort + portOffset).toString();
-    const AKAN_PUBLIC_SERVER_PORT = portOffset ? (8282 + portOffset).toString() : undefined;
+    const { portOffset } = WorkspaceExecutor.getBaseDevEnv();
+    const PORT = (8282 + portOffset).toString();
     return {
       ...process.env,
       AKAN_PUBLIC_APP_NAME: this.name,
@@ -3299,18 +3088,24 @@ class AppExecutor extends SysExecutor {
       NODE_NO_WARNINGS: "1",
       PORT,
       AKAN_PUBLIC_CLIENT_PORT: PORT,
-      ...AKAN_PUBLIC_SERVER_PORT ? { AKAN_PUBLIC_SERVER_PORT } : {},
+      ...portOffset ? { AKAN_PUBLIC_SERVER_PORT: PORT } : {},
       ...env
     };
   }
+  async getDatabaseModeEnv() {
+    const akanConfig = await this.getConfig();
+    return {
+      AKAN_DATABASE_MODE: akanConfig.resolveDatabaseMode(),
+      AKAN_DATABASE_MODES: akanConfig.database.modes.join(",")
+    };
+  }
   async prepareCommand(type) {
     const akanConfig = await this.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
     const routeEnv = {
       AKAN_PUBLIC_BASE_PATHS: [...akanConfig.basePaths].join(","),
       AKAN_PUBLIC_API_PREFIX: akanConfig.api.prefix,
       AKAN_PUBLIC_WS_PREFIX: akanConfig.api.websocketPrefix,
-      AKAN_DATABASE_MODE: databaseMode
+      ...await this.getDatabaseModeEnv()
     };
     Object.assign(process.env, routeEnv);
     if (type === "build") {
@@ -3323,7 +3118,7 @@ class AppExecutor extends SysExecutor {
         ...akanConfig.web.ssr ? [this.cp("public", `${this.dist.cwdPath}/public`, { dereference: true })] : []
       ]);
     } else {
-      await this.removeDir(".akan");
+      await this.#removeDevOutput();
       if (!akanConfig.web.ssr || !akanConfig.web.csr)
         this.logger.verbose(`akan.config.ts disables web.${!akanConfig.web.ssr ? "ssr" : "csr"}; \`akan start\` still serves it, \`akan build\` will not`);
     }
@@ -3339,6 +3134,8 @@ class AppExecutor extends SysExecutor {
       const buildEnv = { ...env };
       delete buildEnv.AKAN_PUBLIC_CLIENT_PORT;
       delete buildEnv.AKAN_PUBLIC_SERVER_PORT;
+      delete buildEnv.AKAN_PUBLIC_OPERATION_MODE;
+      delete process.env.AKAN_PUBLIC_OPERATION_MODE;
       Object.assign(process.env, buildEnv);
     }
     return { env };
@@ -3348,16 +3145,7 @@ class AppExecutor extends SysExecutor {
     if (this.#publicEnv)
       return this.#publicEnv;
     const searchPatterns = [...patterns, "AKAN_PUBLIC_*"];
-    const regexes = searchPatterns.map((pattern) => {
-      let body = "";
-      for (const ch of pattern) {
-        if (ch === "*")
-          body += ".*";
-        else
-          body += ch.replace(/[.+^${}()|[\]\\?]/g, "\\$&");
-      }
-      return new RegExp(`^${body}$`);
-    });
+    const regexes = searchPatterns.map((pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.+^${}()|[\]\\?]/g, "\\$&")).join(".*")}$`));
     const publicEnv = {};
     for (const [k, v] of Object.entries(process.env)) {
       if (typeof v !== "string")
@@ -3386,19 +3174,23 @@ class AppExecutor extends SysExecutor {
     const owners = new Map;
     const devOnlyKeys = new Set;
     const devOnlyDirs = [];
-    for (const root of await this.getPageRoots()) {
-      if (!await FileSys.dirExists(root.dir))
+    const pageRoots = await this.getPageRoots();
+    const libKeyPrefixes = pageRoots.map((root) => root.keyPrefix).filter(Boolean);
+    for (const root of pageRoots) {
+      if (!await FileSys2.dirExists(root.dir))
         continue;
       for await (const rel of glob.scan({
         cwd: root.dir,
         absolute: false,
         onlyFiles: true
       })) {
-        const segments = rel.split(path8.sep);
+        const segments = rel.split(path9.sep);
         if (segments.some((s) => s === "node_modules"))
           continue;
         const posix = `${root.keyPrefix}${segments.join("/")}`;
-        const absPath = path8.join(root.dir, ...segments);
+        if (!root.keyPrefix && libKeyPrefixes.some((prefix) => posix.startsWith(prefix)))
+          continue;
+        const absPath = path9.join(root.dir, ...segments);
         validatePageSourceFile(posix, { filePath: absPath });
         if (!isRouteSourceFile(posix))
           continue;
@@ -3462,7 +3254,7 @@ class AppExecutor extends SysExecutor {
       const entries = await readDirEntries(libsDir).catch(() => []);
       for (const entry of entries.sort()) {
         const dir = `${libsDir}/${entry}`;
-        if (!await FileSys.dirExists(dir))
+        if (!await FileSys2.dirExists(dir))
           continue;
         roots.push({ dir, realDir: await realpath(dir), keyPrefix: `${parent}${AppExecutor.#pageLibsDir}/${entry}/` });
       }
@@ -3487,7 +3279,8 @@ class AppExecutor extends SysExecutor {
       return entries.map((entry) => `${parent}${AppExecutor.#pageLibsDir}/${entry}/`);
     }))).flat();
     const wanted = parents.flatMap((parent) => libs.map((lib) => `${parent}${AppExecutor.#pageLibsDir}/(${lib})/`));
-    if (linked.sort().join(",") === wanted.sort().join(","))
+    const isLink = async (key) => (await lstat(`${this.cwdPath}/page/${key.slice(0, -1)}`).catch(() => null))?.isSymbolicLink() ?? false;
+    if (linked.sort().join(",") === wanted.sort().join(",") && (await Promise.all(linked.map(isLink))).every(Boolean))
       return false;
     await Promise.all(parents.map((parent) => this.removeDir(`${this.cwdPath}/page/${parent}${AppExecutor.#pageLibsDir}`)));
     for (const parent of parents) {
@@ -3503,7 +3296,7 @@ class AppExecutor extends SysExecutor {
   async#resolvePageLibs(syncPageLibs, libDeps) {
     if (!syncPageLibs)
       return [];
-    const hasPageDir = async (lib) => await FileSys.dirExists(`${this.workspace.workspaceRoot}/libs/${lib}/page`);
+    const hasPageDir = async (lib) => await FileSys2.dirExists(`${this.workspace.workspaceRoot}/libs/${lib}/page`);
     if (syncPageLibs === true) {
       const libs = [];
       for (const lib of libDeps)
@@ -3538,12 +3331,12 @@ class AppExecutor extends SysExecutor {
   static async#linkLibAsset(targetPath, linkPath) {
     const isWindows = process.platform === "win32";
     try {
-      const target = isWindows ? targetPath : path8.relative(path8.dirname(linkPath), targetPath);
+      const target = isWindows ? targetPath : path9.relative(path9.dirname(linkPath), targetPath);
       await symlink(target, linkPath, isWindows ? "junction" : "dir");
     } catch (error) {
       if (!isWindows)
         throw error;
-      await mkdir3(linkPath, { recursive: true });
+      await mkdir2(linkPath, { recursive: true });
       await cpEntry(targetPath, linkPath, { recursive: true, dereference: true, force: true });
     }
   }
@@ -3575,13 +3368,14 @@ class AppExecutor extends SysExecutor {
       appPath: this.cwdPath,
       executor: this,
       getPath: (rel) => this.getPath(rel),
-      fileExists: (rel) => FileSys.fileExists(this.getPath(rel)),
+      fileExists: (rel) => FileSys2.fileExists(this.getPath(rel)),
+      readFile: (rel) => this.readFile(rel),
       writeFile: async (rel, content, opts) => {
         await this.writeFile(rel, content, opts);
       },
       readEnvClient: async () => {
-        const envClientPath = path8.join(this.cwdPath, "env", "env.client.ts");
-        if (!await FileSys.fileExists(envClientPath))
+        const envClientPath = path9.join(this.cwdPath, "env", "env.client.ts");
+        if (!await FileSys2.fileExists(envClientPath))
           return null;
         try {
           const envUrl = pathToFileURL(envClientPath);
@@ -3612,16 +3406,6 @@ class AppExecutor extends SysExecutor {
       return true;
     });
   }
-  async getPluginRuntimePackages() {
-    const plugins = await this.collectPlugins();
-    const appConfig = await this.getConfig();
-    const ctx = {
-      appName: this.name,
-      mobile: appConfig.mobile,
-      hasMobilePermission: (permission) => Object.values(appConfig.mobile.targets).some((target) => target.permissions?.includes(permission) ?? false)
-    };
-    return [...new Set(plugins.flatMap((plugin) => plugin.runtimePackages?.(ctx) ?? []))];
-  }
   async increaseBuildNum() {
     await increaseBuildNum(this);
   }
@@ -3637,15 +3421,8 @@ class LibExecutor extends SysExecutor {
     super({ workspace, name, type: "lib" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/libs/${name}`);
   }
-  static #execs = new Map;
   static from(executor, name) {
-    const exec = LibExecutor.#execs.get(name);
-    if (exec)
-      return exec;
-    else if (executor instanceof WorkspaceExecutor)
-      return new LibExecutor({ workspace: executor, name });
-    else
-      return new LibExecutor({ workspace: executor.workspace, name });
+    return new LibExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   #akanConfig = null;
   async getConfig({ refresh } = {}) {
@@ -3668,9 +3445,7 @@ class PkgExecutor extends Executor {
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/pkgs/${name}`);
   }
   static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
-      return new PkgExecutor({ workspace: executor, name });
-    return new PkgExecutor({ workspace: executor.workspace, name });
+    return new PkgExecutor({ workspace: executor instanceof WorkspaceExecutor ? executor : executor.workspace, name });
   }
   #scanInfo = null;
   async scan({ refresh } = {}) {
@@ -3688,9 +3463,12 @@ class PkgExecutor extends Executor {
     const rootVersion = rootDeps[dep];
     if (rootVersion)
       return rootVersion;
+    const overrideVersion = rootPackageJson.overrides?.[dep];
+    if (typeof overrideVersion === "string")
+      return overrideVersion;
     try {
       const packageJsonPath = `pkgs/${dep}/package.json`;
-      if (!await Bun.file(path8.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
+      if (!await Bun.file(path9.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
         return;
       const packageJson = await this.workspace.readJson(packageJsonPath);
       if (packageJson.name === dep)
@@ -3713,16 +3491,8 @@ class PkgExecutor extends Executor {
     }
     if (missingDeps.length > 0)
       throw new Error(`Missing dependency versions in root package.json: ${missingDeps.join(", ")}`);
-    const toDependencyEntries = (names) => names.map((dep) => {
-      const version = dependencyVersions.get(dep);
-      if (!version)
-        throw new Error(`Missing dependency versions in root package.json: ${dep}`);
-      return [dep, version];
-    });
-    return {
-      dependencies: Object.fromEntries(toDependencyEntries(dependencyNames)),
-      devDependencies: Object.fromEntries(toDependencyEntries(devDependencyNames))
-    };
+    const toDependencyMap = (names) => Object.fromEntries(names.map((dep) => [dep, dependencyVersions.get(dep)]));
+    return { dependencies: toDependencyMap(dependencyNames), devDependencies: toDependencyMap(devDependencyNames) };
   }
   async updatePackageJsonDependencies(dependencies = [], devDependencies = []) {
     const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
@@ -3791,4 +3561,4 @@ class ModuleExecutor extends Executor {
   }
 }
 
-export { AGENT_BLOCK_START, AGENT_BLOCK_END, stampBlockVersion, extractBlockVersion, readDevkitVersion, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, CLAUDE_COMMENT_RULE, AsyncDefaultExportDetector, resolveSsrPageEntriesForApp, CodegenLock, rootAllowedFiles, rootAllowedDirs, isAllowedLibFacetRootFile, isScannedRootEntry, AppInfo, Spinner, CommandExecutionError, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };
+export { AGENT_BLOCK_START, AGENT_BLOCK_END, stampBlockVersion, extractBlockVersion, readDevkitVersion, upsertAgentBlock, extractAgentBlock, renderRecipeEntries, collectScopeRecipeSources, renderScopeAgentBlock, CLAUDE_COMMENT_RULE, binPlatforms, AsyncDefaultExportDetector, resolveSsrPageEntriesForApp, CodegenLock, Linter, rootAllowedFiles, rootAllowedDirs, isAllowedLibFacetRootFile, rootEntryHintOf, isScannedRootEntry, AppInfo, Spinner, Executor, WorkspaceExecutor, SysExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };