@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/index-a6sbyy0b.js

@@ -0,0 +1,2769 @@
+// @bun
+import {
+  FileSys
+} from "./index-61keag0s.js";
+import {
+  Spinner
+} from "./index-6pz1j0zj.js";
+import {
+  __require
+} from "./index-r24hmh0q.js";
+
+// pkgs/@akanjs/devkit/executors.ts
+import {
+  exec,
+  fork,
+  spawn as spawn2
+} from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+import { copyFile, mkdir, readdir as readDirEntries, stat } from "fs/promises";
+import path5 from "path";
+import { pathToFileURL } from "url";
+import {
+  capitalize,
+  isRouteSourceFile,
+  Logger,
+  parseRouteModuleKey,
+  validatePageSourceFile,
+  validateSubRoutePageKey
+} from "akanjs/common";
+var {$ } = globalThis.Bun;
+import chalk2 from "chalk";
+
+// pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { resolveAkanI18nConfig } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/akanConfig/types.ts
+import { archs } from "akanjs";
+
+// pkgs/@akanjs/devkit/akanConfig/akanConfig.ts
+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/*"
+];
+var WORKSPACE_BARREL_FACETS = ["ui", "webkit", "common", "client", "server"];
+var SSR_RUNTIME_PACKAGES = ["react", "react-dom", "react-server-dom-webpack"];
+var NATIVE_RUNTIME_PACKAGES = ["sharp"];
+var DEFAULT_BACKEND_RUNTIME_PACKAGES = ["croner"];
+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,
+  ...NATIVE_RUNTIME_PACKAGES,
+  ...DEFAULT_BACKEND_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],
+  formats: ["image/webp"],
+  qualities: [75],
+  minimumCacheTTL: 14400,
+  remotePatterns: [],
+  localPatterns: [{ pathname: "/**" }],
+  dangerouslyAllowSVG: false,
+  maximumRedirects: 3,
+  fetchTimeoutMs: 7000,
+  maxRemoteBytes: 25 * 1024 * 1024
+};
+var normalizeIndexPath = (indexPath) => {
+  const normalized = indexPath?.trim();
+  if (!normalized)
+    return;
+  const path2 = `/${normalized.replace(/^\/+|\/+$/g, "")}`;
+  return path2 === "/" ? "/" : path2;
+};
+var normalizeStringList = (values) => {
+  const normalized = values?.map((value) => value.trim()).filter(Boolean) ?? [];
+  return normalized.length > 0 ? [...new Set(normalized)] : undefined;
+};
+var sanitizeAppIdSegment = (value) => {
+  const cleaned = value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+  if (!cleaned)
+    return "app";
+  return /^[a-z]/.test(cleaned) ? cleaned : `app${cleaned}`;
+};
+var deriveDefaultAppId = (orgName, appName) => `com.${sanitizeAppIdSegment(orgName)}.${sanitizeAppIdSegment(appName)}`;
+var normalizeDeepLinkDomain = (domain) => {
+  const normalized = domain.trim();
+  if (!normalized)
+    return "";
+  try {
+    const url = new URL(normalized.includes("://") ? normalized : `https://${normalized}`);
+    return url.host.toLowerCase();
+  } catch {
+    return normalized.replace(/^https?:\/\//, "").replace(/\/+$/g, "").toLowerCase();
+  }
+};
+var normalizeDeepLinks = (deepLinks) => {
+  if (!deepLinks)
+    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 } } : {}
+  };
+};
+
+class AkanAppConfig {
+  app;
+  rootPackageJson;
+  docker;
+  defaultDatabaseMode;
+  externalLibs;
+  barrelImports;
+  optimizeImports;
+  images;
+  i18n;
+  publicEnv;
+  mobile;
+  hasMobileConfig;
+  secrets;
+  baseDevEnv;
+  libs;
+  plugins;
+  domains = new Set;
+  subRoutes = new Map;
+  basePaths = new Set;
+  branches = new Set(["debug", "develop", "main"]);
+  constructor(app, libs, rootPackageJson, config, baseDevEnv, plugins = []) {
+    this.app = app;
+    this.rootPackageJson = rootPackageJson;
+    this.libs = libs;
+    this.baseDevEnv = baseDevEnv;
+    this.plugins = plugins;
+    this.#applyRoutes(config?.routes);
+    this.defaultDatabaseMode = config?.defaultDatabaseMode ?? "single";
+    this.externalLibs = config?.externalLibs ?? [];
+    this.barrelImports = [
+      ...DEFAULT_BARREL_IMPORTS,
+      ...WORKSPACE_BARREL_FACETS.map((facet) => `@apps/${app.name}/${facet}`),
+      ...libs.flatMap((lib) => WORKSPACE_BARREL_FACETS.map((facet) => `@libs/${lib}/${facet}`)),
+      ...config?.barrelImports ?? []
+    ];
+    this.optimizeImports = [...new Set([...DEFAULT_OPTIMIZE_IMPORTS, ...config?.optimizeImports ?? []])];
+    this.images = mergeImageConfig(config?.images);
+    this.i18n = resolveAkanI18nConfig(config?.i18n);
+    process.env.AKAN_PUBLIC_DEFAULT_LOCALE = this.i18n.defaultLocale;
+    process.env.AKAN_PUBLIC_LOCALES = this.i18n.locales.join(",");
+    this.publicEnv = config?.publicEnv ?? [];
+    this.secrets = config?.secrets ?? [];
+    this.hasMobileConfig = Boolean(config.mobile);
+    this.mobile = this.#resolveMobileConfig(config.mobile);
+    this.docker = this.#makeDockerContent(config?.docker ?? {});
+  }
+  #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,
+        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
+        }
+      };
+      return [name, resolved];
+    }));
+    return {
+      ...rawMobile,
+      appName,
+      appId,
+      version,
+      buildNum,
+      targets,
+      plugins: rawMobile.plugins
+    };
+  }
+  #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";
+  }
+  #applyRoutes(routes = []) {
+    for (const route of routes) {
+      if (route.basePath) {
+        const basePath = route.basePath.replace(/^\/+|\/+$/g, "");
+        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 appName = this.app.name.toLowerCase();
+    const serveDomain = this.baseDevEnv.serveDomain.toLowerCase();
+    if (this.subRoutes.size === 0)
+      this.branches.forEach((branch) => void this.domains.add(`${appName}-${branch}.${serveDomain}`));
+    else
+      Array.from(this.subRoutes.entries()).forEach(([basePath, domains]) => {
+        this.branches.forEach((domain) => void domains.add(`${basePath}-${domain}.${serveDomain}`));
+      });
+  }
+  #getDockerRunScripts(runs) {
+    return runs.map((run) => {
+      if (typeof run === "string")
+        return `RUN ${run}`;
+      else
+        return Object.entries(run).map(([arch, script]) => `RUN if [ "$TARGETARCH" = "${arch}" ]; then     ${script};   fi`).join(`
+`);
+    });
+  }
+  #getDockerImageScript(image, defaultImage) {
+    if (typeof image === "string")
+      return `FROM ${image}`;
+    else
+      return archs.map((arch) => `FROM ${image[arch] ?? defaultImage} AS ${arch}`).join(`
+`);
+  }
+  #makeDockerContent(docker) {
+    if (docker.content)
+      return {
+        content: docker.content,
+        image: {},
+        preRuns: [],
+        postRuns: [],
+        command: []
+      };
+    const preRunScripts = this.#getDockerRunScripts(docker.preRuns ?? []);
+    const postRunScripts = this.#getDockerRunScripts(docker.postRuns ?? []);
+    const imageScript = docker.image ? this.#getDockerImageScript(docker.image, "oven/bun:1-slim") : "FROM oven/bun:1-slim";
+    const command = docker.command ?? ["bun", "main.js"];
+    const content = `${imageScript}
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y --no-install-recommends git redis build-essential python3 ca-certificates fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 lsb-release wget xdg-utils udev ffmpeg
+ARG TARGETARCH
+${preRunScripts.join(`
+`)}
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+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_OPERATION_MODE=cloud
+
+CMD [${command.map((c) => `"${c}"`).join(",")}]`;
+    return {
+      content,
+      image: imageScript,
+      preRuns: docker.preRuns ?? [],
+      postRuns: docker.postRuns ?? [],
+      command
+    };
+  }
+  static #importGeneration = 0;
+  static async importConfigModule(cwdPath, { bustImportCache = false } = {}) {
+    const configPath = `${cwdPath}/akan.config.ts`;
+    const importPath = bustImportCache ? `${configPath}?akanConfigGeneration=${++AkanAppConfig.#importGeneration}` : configPath;
+    return await import(importPath).then((mod) => mod.default);
+  }
+  static async from(app, { bustImportCache = false } = {}) {
+    const [configImp, baseDevEnv, libs, rootPackageJson] = await Promise.all([
+      AkanAppConfig.importConfigModule(app.cwdPath, { bustImportCache }),
+      WorkspaceExecutor.getBaseDevEnv(path.join(app.workspace.workspaceRoot, ".env")),
+      app.workspace.getLibs(),
+      app.workspace.getPackageJson()
+    ]);
+    const resolved = typeof configImp === "function" ? configImp(app) : configImp;
+    const { plugins, ...config } = resolved ?? {};
+    return new AkanAppConfig(app, libs, rootPackageJson, config, baseDevEnv, plugins ?? []);
+  }
+  #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,
+      ...NATIVE_RUNTIME_PACKAGES,
+      ...DEFAULT_BACKEND_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 = path.dirname(fileURLToPath(import.meta.url));
+  const packageJsonPaths = [
+    path.join(sourceDir, "../../../akanjs/package.json"),
+    path.join(process.cwd(), "pkgs/akanjs/package.json"),
+    path.join(path.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;
+  plugins;
+  constructor(lib, config, plugins = []) {
+    this.lib = lib;
+    this.externalLibs = config?.externalLibs ?? [];
+    this.plugins = plugins;
+  }
+  static async from(lib) {
+    const [configImp] = await Promise.all([import(`${lib.cwdPath}/akan.config.ts`).then((mod) => mod.default)]);
+    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 = path.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 = path.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/getDirname.ts
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var getDirname = (url) => path2.dirname(fileURLToPath2(url));
+
+// pkgs/@akanjs/devkit/linter.ts
+import { spawn } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import path3 from "path";
+import chalk from "chalk";
+
+class Linter {
+  lintRoot;
+  #biomeBin;
+  constructor(cwdPath) {
+    this.lintRoot = this.#findBiomeRootPath(cwdPath);
+    const localBiomeBin = path3.join(this.lintRoot, "node_modules/.bin/biome");
+    this.#biomeBin = existsSync(localBiomeBin) ? localBiomeBin : "biome";
+  }
+  #findBiomeRootPath(dir) {
+    const configPath = path3.join(dir, "biome.json");
+    if (existsSync(configPath))
+      return dir;
+    const parentDir = path3.dirname(dir);
+    if (parentDir === dir)
+      throw new Error(`biome.json not found from ${dir}`);
+    return this.#findBiomeRootPath(parentDir);
+  }
+  #toBiomePath(filePath) {
+    const relativePath = path3.relative(this.lintRoot, filePath);
+    if (!relativePath.startsWith("..") && !path3.isAbsolute(relativePath))
+      return relativePath;
+    return filePath;
+  }
+  #resolveFilePath(filePath) {
+    return path3.isAbsolute(filePath) ? filePath : path3.join(this.lintRoot, filePath);
+  }
+  async#runBiome(args, input) {
+    return await new Promise((resolve, reject) => {
+      const proc = spawn(this.#biomeBin, args, {
+        cwd: this.lintRoot,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("error", reject);
+      proc.on("close", (code) => resolve({ stdout, stderr, code }));
+      proc.stdin.end(input);
+    });
+  }
+  #parseBiomeReport(output) {
+    const jsonStart = output.indexOf("{");
+    const jsonEnd = output.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1 || jsonEnd < jsonStart)
+      throw new Error(output.trim() || "No Biome JSON output");
+    return JSON.parse(output.slice(jsonStart, jsonEnd + 1));
+  }
+  #diagnosticFilePath(diagnostic, fallbackFilePath) {
+    const diagnosticPath = diagnostic.location?.path;
+    if (!diagnosticPath)
+      return fallbackFilePath;
+    return path3.isAbsolute(diagnosticPath) ? diagnosticPath : path3.join(this.lintRoot, diagnosticPath);
+  }
+  #createLintMessage(diagnostic) {
+    const start = diagnostic.location?.start;
+    const end = diagnostic.location?.end;
+    return {
+      line: Math.max(1, start?.line ?? 1),
+      column: Math.max(1, start?.column ?? 1),
+      endLine: end?.line,
+      endColumn: end?.column,
+      message: diagnostic.message,
+      ruleId: diagnostic.category ?? null,
+      severity: diagnostic.severity === "error" ? 2 : 1
+    };
+  }
+  #toLintResults(report, filePath) {
+    const resultsByPath = new Map;
+    for (const diagnostic of report.diagnostics ?? []) {
+      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 message = this.#createLintMessage(diagnostic);
+      result.messages.push(message);
+      if (message.severity === 2)
+        result.errorCount += 1;
+      else
+        result.warningCount += 1;
+      resultsByPath.set(diagnosticFilePath, result);
+    }
+    return [
+      resultsByPath.get(filePath) ?? {
+        filePath,
+        messages: [],
+        errorCount: 0,
+        warningCount: 0,
+        fixableErrorCount: 0,
+        fixableWarningCount: 0
+      },
+      ...[...resultsByPath.entries()].filter(([resultPath]) => resultPath !== filePath).map(([, result]) => result)
+    ];
+  }
+  #splitMessages(results) {
+    const messages = results.flatMap((result) => result.messages);
+    return {
+      errors: messages.filter((message) => message.severity === 2),
+      warnings: messages.filter((message) => message.severity === 1)
+    };
+  }
+  async#checkFile(filePath, { write = false } = {}) {
+    const originalContent = existsSync(filePath) ? readFileSync(filePath, "utf8") : "";
+    const { stdout, stderr } = await this.#runBiome([
+      "check",
+      ...write ? ["--write"] : [],
+      "--reporter=json",
+      "--max-diagnostics=none",
+      "--no-errors-on-unmatched",
+      "--config-path",
+      path3.join(this.lintRoot, "biome.json"),
+      this.#toBiomePath(filePath)
+    ]);
+    const report = this.#parseBiomeReport(stdout || stderr);
+    const results = this.#toLintResults(report, filePath);
+    const { errors, warnings } = this.#splitMessages(results);
+    const output = write && existsSync(filePath) ? readFileSync(filePath, "utf8") : undefined;
+    return {
+      fixed: write && output !== originalContent,
+      output,
+      results,
+      errors,
+      warnings
+    };
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    if (fix)
+      return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+  async lintFile(filePath) {
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      throw new Error(`File not found: ${filePath}`);
+    return await this.#checkFile(resolvedFilePath);
+  }
+  formatLintResults(results) {
+    if (results.length === 0)
+      return "No files to lint";
+    const output = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+      if (result.messages.length > 0) {
+        output.push(`
+${chalk.cyan(result.filePath)}`);
+        let sourceLines = [];
+        if (existsSync(result.filePath)) {
+          try {
+            const sourceContent = readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split(`
+`);
+          } catch {}
+        }
+        result.messages.forEach((message) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? chalk.red : chalk.yellow;
+          const icon = message.severity === 2 ? "x" : "!";
+          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
+          output.push(`
+  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.bold(`${message.line}:${message.column}`)}`);
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+            output.push(`
+${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+    if (totalErrors === 0 && totalWarnings === 0)
+      return chalk.bold("No Biome errors or warnings found");
+    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? chalk.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`
+${errorText}, ${warningText} found`];
+    return summary.concat(output).join(`
+`);
+  }
+  async getDetailedLintInfo(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const details = results.flatMap((result) => result.messages.map((message) => ({
+      line: message.line,
+      column: message.column,
+      message: message.message,
+      ruleId: message.ruleId,
+      severity: message.severity === 2 ? "error" : "warning"
+    })));
+    const stats = results.reduce((acc, result) => ({
+      errorCount: acc.errorCount + result.errorCount,
+      warningCount: acc.warningCount + result.warningCount,
+      fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+      fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
+    }), {
+      errorCount: 0,
+      warningCount: 0,
+      fixableErrorCount: 0,
+      fixableWarningCount: 0
+    });
+    return { results, details, stats };
+  }
+  async hasNoLintErrors(filePath) {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch {
+      return false;
+    }
+  }
+  async getErrors(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+  }
+  async getWarnings(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+  }
+  async fixFile(filePath, dryRun = false) {
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      throw new Error(`File not found: ${filePath}`);
+    if (!dryRun)
+      return await this.#checkFile(resolvedFilePath, { write: true });
+    const source = readFileSync(resolvedFilePath, "utf8");
+    const { stdout } = await this.#runBiome([
+      "check",
+      "--write",
+      "--config-path",
+      path3.join(this.lintRoot, "biome.json"),
+      "--stdin-file-path",
+      this.#toBiomePath(resolvedFilePath)
+    ], source);
+    const lintResult = await this.lintFile(resolvedFilePath);
+    return { ...lintResult, fixed: stdout !== source, output: stdout };
+  }
+  async getConfigForFile(filePath) {
+    const resolvedFilePath = this.#resolveFilePath(filePath);
+    if (!existsSync(resolvedFilePath))
+      throw new Error(`File not found: ${filePath}`);
+    return JSON.parse(readFileSync(path3.join(this.lintRoot, "biome.json"), "utf8"));
+  }
+  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;
+      });
+    });
+    return ruleCounts;
+  }
+}
+
+// pkgs/@akanjs/devkit/scanInfo.ts
+import { rm } from "fs/promises";
+import path4 from "path";
+var databaseFileTypes = [
+  "constant",
+  "dictionary",
+  "document",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+var appRootAllowedFiles = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json",
+  "tsconfig.tsbuildinfo"
+]);
+var generatedRootCapacitorConfigFiles = ["capacitor.config.js", "capacitor.config.json"];
+var appRootAllowedDirs = new Set([
+  ".akan",
+  "android",
+  "env",
+  "ios",
+  "lib",
+  "mobile",
+  "page",
+  "private",
+  "public",
+  "script",
+  "ui",
+  "srvkit",
+  "webkit",
+  "common",
+  "secrets"
+]);
+var libRootAllowedFiles = new Set([
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts"
+]);
+var internalLibDirs = new Set(["__lib", "__scalar"]);
+var moduleNonUiFileTypes = {
+  database: new Set(["constant", "dictionary", "document", "service", "signal", "store"]),
+  service: new Set(["dictionary", "service", "signal", "store"]),
+  scalar: new Set(["constant", "dictionary", "document"])
+};
+var moduleUiFileTypes = {
+  database: new Set(["Template", "Unit", "Util", "View", "Zone"]),
+  service: new Set(["Util", "Zone"]),
+  scalar: new Set(["Template", "Unit"])
+};
+var testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
+var rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
+var createDependencyScanner = async (exec) => (await import("./dependencyScanner-m4x5maek.js")).TypeScriptDependencyScanner.from(exec);
+var isAllowedTestFile = (filename) => testFilePattern.test(filename);
+var isAllowedLibRootFile = (filename) => libRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
+var getScanPath = (exec, relativePath) => path4.posix.join(`${exec.type}s`, exec.name, relativePath.split(path4.sep).join("/"));
+async function clearGeneratedRootCapacitorConfigs(exec) {
+  if (exec.type !== "app")
+    return;
+  await Promise.all(generatedRootCapacitorConfigFiles.map((filename) => rm(exec.getPath(filename), { force: true })));
+}
+var getModuleNameFromPath = (kind, modulePath) => {
+  const dirname = path4.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}`);
+  };
+  if (exec.type === "app") {
+    const { files, dirs } = await exec.getFilesAndDirs(".");
+    files.filter((filename) => !appRootAllowedFiles.has(filename)).forEach((filename) => {
+      addViolation(filename, "unsupported app root file");
+    });
+    dirs.filter((dirname) => !appRootAllowedDirs.has(dirname)).forEach((dirname) => {
+      addViolation(dirname, "unsupported app root folder");
+    });
+  }
+  libRoot.files.filter((filename) => !isAllowedLibRootFile(filename)).forEach((filename) => {
+    addViolation(path4.join("lib", filename), "unsupported lib root file");
+  });
+  libRoot.dirs.filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname)).forEach((dirname) => {
+    addViolation(path4.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", path4.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path4.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path4.join("lib/__scalar", dirname)))
+  ]);
+  if (violations.length > 0) {
+    throw new Error(`[scan-convention]
+${violations.sort().map((violation) => `- ${violation}`).join(`
+`)}`);
+  }
+}
+async function validateModuleFiles(exec, violations, kind, modulePath) {
+  const { files, dirs } = await exec.getFilesAndDirs(modulePath);
+  const moduleName = getModuleNameFromPath(kind, modulePath);
+  dirs.forEach((dirname) => {
+    violations.push(`${getScanPath(exec, path4.join(modulePath, dirname))}: unsupported module folder`);
+  });
+  const uiModuleName = moduleName[0].toUpperCase() + moduleName.slice(1);
+  files.forEach((filename) => {
+    const filePath = path4.join(modulePath, filename);
+    if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename))
+      return;
+    if (filename === `${moduleName}.abstract.md`)
+      return;
+    const uiMatch = filename.match(/^([A-Z][A-Za-z0-9]+)\.([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;
+    }
+    violations.push(`${getScanPath(exec, filePath)}: unsupported module file`);
+  });
+}
+
+class ScanInfo {
+  scanResult;
+  name;
+  scalar = new Map;
+  service = new Map;
+  database = new Map;
+  file = Object.fromEntries(databaseFileTypes.map((type) => [
+    type,
+    { all: new Set, databases: new Set, services: new Set, scalars: new Set }
+  ]));
+  static async getScanResult(exec) {
+    const [akanConfig2, scanner, pkgs, libs] = await Promise.all([
+      exec.getConfig(),
+      createDependencyScanner(exec),
+      exec.workspace.getPkgs(),
+      exec.workspace.getLibs()
+    ]);
+    const { pkgDeps, libDeps, npmDeps, npmDevDeps } = await scanner.getMonorepoDependencies(exec.name, { pkgs, libs });
+    const files = {
+      constant: { databases: [], scalars: [] },
+      dictionary: { databases: [], services: [], scalars: [] },
+      document: { databases: [], scalars: [] },
+      service: { databases: [], services: [] },
+      signal: { databases: [], services: [] },
+      store: { databases: [], services: [] },
+      template: { databases: [], services: [], scalars: [] },
+      unit: { databases: [], services: [], scalars: [] },
+      util: { databases: [], services: [], scalars: [] },
+      view: { databases: [], services: [], scalars: [] },
+      zone: { databases: [], services: [], scalars: [] }
+    };
+    const [libRoot, scalarDirs] = await Promise.all([exec.getFilesAndDirs("lib"), exec.readdir("lib/__scalar")]);
+    await assertScanConvention(exec, libRoot);
+    const { dirs: dirnames } = libRoot;
+    const databaseDirs = [];
+    const serviceDirs = [];
+    dirnames.forEach((name) => {
+      if (name.startsWith("_")) {
+        if (name.startsWith("__"))
+          return;
+        else
+          serviceDirs.push(name);
+      } else
+        databaseDirs.push(name);
+    });
+    await Promise.all([
+      ...databaseDirs.map(async (name) => {
+        const filenames = await exec.readdir(path4.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(path4.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(path4.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);
+        });
+      })
+    ]);
+    const routes = exec.type === "lib" ? [] : await exec.getPageKeys();
+    const scanResult = {
+      name: exec.name,
+      type: exec.type,
+      repoName: exec.workspace.repoName,
+      serveDomain: WorkspaceExecutor.getBaseDevEnv(path4.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
+      akanConfig: akanConfig2,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: npmDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
+      devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
+      routes
+    };
+    return scanResult;
+  }
+  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);
+      });
+    });
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  getDatabaseModules() {
+    return [...this.database.keys()];
+  }
+  getServiceModules() {
+    return [...this.service.keys()];
+  }
+  getScalarModules() {
+    return [...this.scalar.keys()];
+  }
+}
+var isAkanFrameworkDependency = (dep) => dep === "akanjs" || dep.startsWith("akanjs/");
+
+class AppInfo extends ScanInfo {
+  type = "app";
+  exec;
+  akanConfig;
+  libDeps;
+  static appInfos = new Map;
+  static async fromExecutor(exec, options = {}) {
+    const existingAppInfo = AppInfo.appInfos.get(exec.name);
+    if (existingAppInfo && !options.refresh)
+      return existingAppInfo;
+    const scanResult = await ScanInfo.getScanResult(exec);
+    await Promise.all(scanResult.libDeps.map(async (libName) => {
+      LibInfo.loadedLibs.add(libName);
+      const libExecutor = LibExecutor.from(exec, libName);
+      LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+    }));
+    const libDeps = await AppInfo.#getAllLibDeps(exec, scanResult.libDeps);
+    const appInfo = new AppInfo(exec, scanResult, libDeps);
+    AppInfo.appInfos.set(exec.name, appInfo);
+    return appInfo;
+  }
+  constructor(exec, scanResult, libDeps) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+    this.libDeps = libDeps;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  static async#getAllLibDeps(exec, libDeps, libSet = new Set) {
+    await Promise.all(libDeps.map(async (libName) => {
+      if (libSet.has(libName))
+        return;
+      libSet.add(libName);
+      const libExecutor = LibExecutor.from(exec, libName);
+      const libInfo = await LibInfo.fromExecutor(libExecutor);
+      const libScanResult = libInfo.getScanResult();
+      if (libScanResult.libDeps.length > 0)
+        await AppInfo.#getAllLibDeps(exec, libScanResult.libDeps, libSet);
+    }));
+    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();
+  }
+  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];
+    }));
+  }
+}
+
+class LibInfo extends ScanInfo {
+  type = "lib";
+  exec;
+  akanConfig;
+  static loadedLibs = new Set;
+  static libInfos = new Map;
+  static #sortedLibIndices = null;
+  static getSortedLibIndices() {
+    if (LibInfo.#sortedLibIndices)
+      return LibInfo.#sortedLibIndices;
+    LibInfo.#sortedLibIndices = new Map([...LibInfo.libInfos.entries()].sort(([_, libInfoA], [__, libInfoB]) => libInfoA.getScanResult().libDeps.includes(libInfoB.name) ? 1 : -1).map(([libName], index) => [libName, index]));
+    return LibInfo.#sortedLibIndices;
+  }
+  static async fromExecutor(exec, { refresh } = {}) {
+    const existingLibInfo = LibInfo.libInfos.get(exec.name);
+    if (existingLibInfo && !refresh)
+      return existingLibInfo;
+    const scanResult = await ScanInfo.getScanResult(exec);
+    await Promise.all(scanResult.libDeps.filter((libName) => !LibInfo.loadedLibs.has(libName)).map(async (libName) => {
+      LibInfo.loadedLibs.add(libName);
+      const libExecutor = LibExecutor.from(exec, libName);
+      LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+    }));
+    const libInfo = new LibInfo(exec, scanResult);
+    LibInfo.libInfos.set(exec.name, libInfo);
+    LibInfo.#sortedLibIndices = null;
+    return libInfo;
+  }
+  constructor(exec, scanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  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();
+  }
+  getLibInfo(libName) {
+    if (!this.getScanResult().libDeps.includes(libName))
+      return;
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(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];
+    }));
+  }
+}
+
+class PkgInfo {
+  exec;
+  name;
+  scanResult;
+  static async scanExecutor(exec) {
+    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((path5) => tsconfig.compilerOptions.paths?.[path5]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path5) => path5.replace("/*", "")));
+    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path5) => {
+      const pathSplitLength = path5.split("/").length;
+      return (tsconfig.compilerOptions.paths?.[path5]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((pkg) => pkg !== exec.name);
+    const pkgScanResult = {
+      name: exec.name,
+      pkgDeps,
+      dependencies: [...npmDepSet]
+    };
+    return pkgScanResult;
+  }
+  static #pkgInfos = new Map;
+  static async fromExecutor(exec, options = {}) {
+    const existingPkgInfo = PkgInfo.#pkgInfos.get(exec.name);
+    if (existingPkgInfo && !options.refresh)
+      return existingPkgInfo;
+    const scanResult = await PkgInfo.scanExecutor(exec);
+    const pkgInfo = new PkgInfo(exec, scanResult);
+    PkgInfo.#pkgInfos.set(exec.name, pkgInfo);
+    return pkgInfo;
+  }
+  constructor(exec, scanResult) {
+    this.exec = exec;
+    this.name = exec.name;
+    this.scanResult = scanResult;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+}
+
+class WorkspaceInfo {
+  appInfos;
+  libInfos;
+  pkgInfos;
+  constructor(appInfos = new Map, libInfos = new Map, pkgInfos = new Map) {
+    this.appInfos = appInfos;
+    this.libInfos = libInfos;
+    this.pkgInfos = pkgInfos;
+  }
+  static #workspaceInfos = new Map;
+  static async fromExecutor(exec, options = {}) {
+    const existingWorkspaceInfo = WorkspaceInfo.#workspaceInfos.get(exec.name);
+    if (existingWorkspaceInfo && !options.refresh)
+      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();
+      }))
+    ]);
+    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);
+    return 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 formatCommandForDisplay = (command, args = []) => [command, ...args].map(formatCommandArg).join(" ");
+
+class CommandExecutionError extends Error {
+  command;
+  args;
+  cwd;
+  code;
+  signal;
+  stdout;
+  stderr;
+  constructor({
+    command,
+    args = [],
+    cwd,
+    code,
+    signal,
+    stdout = "",
+    stderr = "",
+    cause
+  }) {
+    const displayCommand = formatCommandForDisplay(command, args);
+    const status = signal ? `signal: ${signal}` : `exit code: ${code ?? "unknown"}`;
+    const output = (stderr || stdout).trim();
+    super([`Command failed: ${displayCommand}`, `cwd: ${cwd}`, status, output ? `
+${output}` : ""].join(`
+`), {
+      cause
+    });
+    this.name = "CommandExecutionError";
+    this.command = command;
+    this.args = args;
+    this.cwd = cwd;
+    this.code = code;
+    this.signal = signal;
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+}
+var execEmoji = {
+  workspace: "\uD83C\uDFE0",
+  app: "\uD83D\uDE80",
+  lib: "\uD83D\uDD27",
+  pkg: "\uD83D\uDCE6",
+  dist: "\uD83D\uDCBF",
+  module: "\u2699\uFE0F",
+  default: "\u2708\uFE0F"
+};
+var parseEnvFile = (envPath) => {
+  const env = {};
+  const content = (() => {
+    try {
+      return readFileSync2(envPath, "utf8");
+    } catch {
+      return "";
+    }
+  })();
+  for (const line of content.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const normalized = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trim() : trimmed;
+    const separatorIndex = normalized.indexOf("=");
+    if (separatorIndex <= 0)
+      continue;
+    const key = normalized.slice(0, separatorIndex).trim();
+    let value = normalized.slice(separatorIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    env[key] = value;
+  }
+  return env;
+};
+
+class Executor {
+  static verbose = false;
+  static setVerbose(verbose) {
+    Executor.verbose = verbose;
+  }
+  name;
+  logger;
+  logs;
+  cwdPath;
+  emoji = execEmoji.default;
+  typeChecker = null;
+  linter = null;
+  constructor(name, cwdPath) {
+    this.name = name;
+    this.logger = new Logger(name);
+    this.logs = [];
+    this.cwdPath = cwdPath;
+  }
+  #stdout(data) {
+    if (Executor.verbose)
+      Logger.raw(chalk2.dim(data.toString()));
+  }
+  #stderr(data) {
+    Logger.raw(chalk2.red(data.toString()));
+  }
+  exec(command, options = {}) {
+    const cwd = options.cwd?.toString() ?? this.cwdPath;
+    const proc = exec(command, { 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.#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
+          }));
+        else
+          resolve({ 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);
+      });
+    });
+  }
+  spawnSync(command, args = [], options = {}) {
+    const proc = spawn2(command, args, {
+      cwd: this.cwdPath,
+      ...options
+    });
+    return proc;
+  }
+  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 });
+      });
+    });
+  }
+  getPath(filePath) {
+    if (path5.isAbsolute(filePath))
+      return filePath;
+    if (filePath.startsWith("."))
+      return path5.join(this.cwdPath, filePath);
+    const baseParts = this.cwdPath.split(/[\\/]/).filter(Boolean);
+    const targetParts = filePath.split(/[\\/]/).filter(Boolean);
+    let overlapLength = 0;
+    for (let i = 1;i <= Math.min(baseParts.length, targetParts.length); i++) {
+      let isOverlap = true;
+      for (let j = 0;j < i; j++)
+        if (baseParts[baseParts.length - i + j] !== targetParts[j]) {
+          isOverlap = false;
+          break;
+        }
+      if (isOverlap)
+        overlapLength = i;
+    }
+    return path5.join(this.cwdPath, ...targetParts.slice(overlapLength));
+  }
+  async mkdir(dirPath) {
+    const writePath = this.getPath(dirPath);
+    if (!await FileSys.dirExists(writePath))
+      await mkdir(writePath, { recursive: true });
+    this.logger.verbose(`Make directory ${writePath}`);
+    return this;
+  }
+  async readdir(dirPath) {
+    const readPath = this.getPath(dirPath);
+    try {
+      const glob = new Bun.Glob("*");
+      return Array.from(glob.scanSync({ cwd: readPath, onlyFiles: false }));
+    } catch {
+      return [];
+    }
+  }
+  async getAllFiles(pattern = "**/*", { cwd } = {}) {
+    const glob = new Bun.Glob(pattern);
+    return Array.from(glob.scanSync({ cwd: cwd ?? this.cwdPath, onlyFiles: true }));
+  }
+  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 dirs = allEntries.filter((entry) => !files.includes(entry));
+    return { files, dirs };
+  }
+  async exists(filePath) {
+    const readPath = this.getPath(filePath);
+    return await FileSys.exists(readPath);
+  }
+  async remove(filePath) {
+    const readPath = this.getPath(filePath);
+    if (await FileSys.fileExists(readPath))
+      await FileSys.delete(readPath);
+    this.logger.verbose(`Remove file ${readPath}`);
+    return this;
+  }
+  async removeDir(dirPath) {
+    const readPath = this.getPath(dirPath);
+    if (await FileSys.dirExists(readPath))
+      await $`rm -rf ${readPath}`;
+    this.logger.verbose(`Remove directory ${readPath}`);
+    return this;
+  }
+  async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
+    const writePath = this.getPath(filePath);
+    const dir = path5.dirname(writePath);
+    if (!await FileSys.dirExists(dir))
+      await mkdir(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 (currentContent === contentStr || !overwrite) {
+        this.logger.verbose(`File ${writePath} is unchanged`);
+        contentStr = currentContent;
+      } else {
+        await FileSys.writeText(writePath, contentStr);
+        if (Logger.isVerbose())
+          this.logger.rawLog(chalk2.yellow(`File Update: ${filePath}`));
+      }
+    } else {
+      await FileSys.writeText(writePath, contentStr);
+      if (!silent)
+        this.logger.rawLog(chalk2.green(`File Create: ${filePath}`));
+    }
+    return { filePath: writePath, content: contentStr };
+  }
+  async writeJson(filePath, content) {
+    await this.writeFile(filePath, content);
+  }
+  async getLocalFile(targetPath) {
+    const filePath = path5.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);
+  }
+  async readJson(filePath) {
+    const readPath = this.getPath(filePath);
+    return await FileSys.readJson(readPath);
+  }
+  async cp(srcPath, destPath) {
+    const src = this.getPath(srcPath);
+    const dest = this.getPath(destPath);
+    if (!await FileSys.exists(src))
+      return;
+    const isDirectory = (await stat(src)).isDirectory();
+    if (!await FileSys.exists(dest) && isDirectory)
+      await mkdir(dest, { recursive: true });
+    await $`cp -r ${src}${isDirectory ? "/." : ""} ${dest}`;
+  }
+  log(msg) {
+    this.logger.info(msg);
+    return this;
+  }
+  verbose(msg) {
+    this.logger.verbose(msg);
+    return this;
+  }
+  debug(msg) {
+    this.logger.debug(msg);
+    return this;
+  }
+  spinning(msg, { prefix = `${this.emoji}${this.name}`, indent = 0, enableSpin = !Executor.verbose } = {}) {
+    return new Spinner(msg, { prefix, indent, enableSpin }).start();
+  }
+  #tsconfig = null;
+  async getTsConfig(pathname = "tsconfig.json", { refresh } = {}) {
+    if (this.#tsconfig && !refresh)
+      return this.#tsconfig;
+    const 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;
+    }
+    this.#tsconfig = tsconfig;
+    return tsconfig;
+  }
+  async setTsConfig(tsconfig) {
+    await this.writeJson("tsconfig.json", tsconfig);
+    this.#tsconfig = tsconfig;
+  }
+  #packageJson = null;
+  async getPackageJson({ refresh } = {}) {
+    if (this.#packageJson && !refresh)
+      return this.#packageJson;
+    const packageJson = await this.readJson("package.json");
+    this.#packageJson = packageJson;
+    return packageJson;
+  }
+  async setPackageJson(packageJson) {
+    await this.writeJson("package.json", packageJson);
+    this.#packageJson = packageJson;
+  }
+  #gitignorePatterns = [];
+  async getGitignorePatterns() {
+    if (this.#gitignorePatterns.length)
+      return this.#gitignorePatterns;
+    const gitignore = await this.readFile(".gitignore");
+    this.#gitignorePatterns = gitignore.split(`
+`).map((line) => line.trim()).filter((line) => !!line && !line.startsWith("#"));
+    return this.#gitignorePatterns;
+  }
+  async#applyTemplateFile({
+    templatePath,
+    targetPath,
+    scanInfo,
+    overwrite = true
+  }, dict = {}, options = {}) {
+    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 : path5.basename(targetPath).replace(".js", ".ts");
+      const content = typeof result === "object" ? result.content : result;
+      const dirname = path5.dirname(targetPath);
+      const convertedTargetPath = Object.entries(dict).reduce((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), `${dirname}/${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((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), 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(path5.extname(targetPath).toLowerCase())) {
+      const convertedTargetPath = Object.entries(dict).reduce((path6, [key, value]) => path6.replace(new RegExp(`__${key}__`, "g"), value), targetPath);
+      const writePath = this.getPath(convertedTargetPath);
+      const dirname = path5.dirname(writePath);
+      if (!await FileSys.dirExists(dirname))
+        await mkdir(dirname, { recursive: true });
+      await copyFile(templatePath, writePath);
+      this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
+      return { filePath: writePath, content: "" };
+    } else
+      return null;
+  }
+  async _applyTemplate({
+    basePath,
+    template,
+    scanInfo,
+    dict = {},
+    options = {},
+    overwrite = true
+  }) {
+    const templateRoot = await this.#resolveTemplateRoot();
+    const templatePath = `${templateRoot}${template ? `/${template}` : ""}`;
+    const prefixTemplatePath = templatePath;
+    if ((await stat(prefixTemplatePath)).isFile()) {
+      const filename = path5.basename(prefixTemplatePath);
+      const fileContent = await this.#applyTemplateFile({
+        templatePath: prefixTemplatePath,
+        targetPath: path5.join(basePath, filename),
+        scanInfo,
+        overwrite
+      }, dict, options);
+      return fileContent ? [fileContent] : [];
+    } else {
+      const subdirs = await readDirEntries(templatePath);
+      const fileContents = (await Promise.all(subdirs.map(async (subdir) => {
+        const subpath = path5.join(templatePath, subdir);
+        if ((await stat(subpath)).isFile()) {
+          const fileContent = await this.#applyTemplateFile({
+            templatePath: subpath,
+            targetPath: path5.join(basePath, subdir),
+            scanInfo,
+            overwrite
+          }, dict, options);
+          return fileContent ? [fileContent] : [];
+        } else
+          return await this._applyTemplate({
+            basePath: path5.join(basePath, subdir),
+            template: path5.join(template, subdir),
+            scanInfo,
+            dict,
+            overwrite,
+            options
+          });
+      }))).flat();
+      return fileContents;
+    }
+  }
+  async#resolveTemplateRoot() {
+    const candidates = [
+      path5.resolve(getDirname(import.meta.url), "templates"),
+      path5.resolve(getDirname(import.meta.url), "../cli/templates")
+    ];
+    for (const candidate of candidates) {
+      if (await FileSys.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)]))
+    };
+    return this._applyTemplate({ ...options, dict });
+  }
+  async getTypeChecker() {
+    const { TypeChecker } = await import("./typeChecker-kravn7ns.js");
+    this.typeChecker ??= new TypeChecker(this);
+    return this.typeChecker;
+  }
+  async typeCheck(filePath) {
+    const path6 = this.getPath(filePath);
+    const typeChecker = await this.getTypeChecker();
+    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(path6);
+    const message = typeChecker.formatDiagnostics(fileDiagnostics);
+    return { fileDiagnostics, fileErrors, fileWarnings, message };
+  }
+  async typeCheckAsync(filePath) {
+    const path6 = this.getPath(filePath);
+    const entry = await this.#resolveTypecheckWorkerEntry();
+    const proc = Bun.spawn([process.execPath, entry], {
+      cwd: this.cwdPath,
+      env: {
+        ...process.env,
+        AKAN_TYPECHECK_CWD: this.cwdPath,
+        AKAN_TYPECHECK_FILE: path6
+      },
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (exitCode !== 0)
+      throw new Error((stderr || stdout).trim() || `Typecheck failed with exit code ${exitCode}`);
+    const result = JSON.parse(stdout);
+    return {
+      fileDiagnostics: Array.from({ length: result.fileDiagnosticsCount }),
+      fileErrors: Array.from({ length: result.fileErrorsCount }),
+      fileWarnings: Array.from({ length: result.fileWarningsCount }),
+      message: result.message
+    };
+  }
+  async#resolveTypecheckWorkerEntry() {
+    const dirname = getDirname(import.meta.url);
+    const candidates = [
+      path5.join(process.cwd(), "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path5.join(process.cwd(), "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path5.join(dirname, "typecheck/typecheck.proc.ts"),
+      path5.join(dirname, "typecheck.proc.js"),
+      path5.join(dirname, "typecheck.proc.ts")
+    ];
+    for (const candidate of candidates)
+      if (await Bun.file(candidate).exists())
+        return candidate;
+    throw new Error(`[devkit] typecheck worker entry not found; looked in: ${candidates.join(", ")}`);
+  }
+  getLinter() {
+    this.linter ??= new Linter(this.cwdPath);
+    return this.linter;
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    const path6 = this.getPath(filePath);
+    const linter = this.getLinter();
+    const { results, errors, warnings } = await linter.lint(path6, {
+      fix,
+      dryRun
+    });
+    const message = linter.formatLintResults(results);
+    return { results, message, errors, warnings };
+  }
+}
+
+class WorkspaceExecutor extends Executor {
+  workspaceRoot;
+  repoName;
+  emoji = execEmoji.workspace;
+  constructor({ workspaceRoot, repoName }) {
+    super("workspace", workspaceRoot);
+    this.workspaceRoot = workspaceRoot;
+    this.repoName = repoName;
+  }
+  static #execs = new Map;
+  static fromRoot({
+    workspaceRoot = process.cwd(),
+    repoName = path5.basename(process.cwd())
+  } = {}) {
+    return WorkspaceExecutor.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
+  }
+  static getBaseDevEnv(envPath) {
+    const sourceEnv = envPath ? { ...process.env, ...parseEnvFile(envPath) } : process.env;
+    const appName = sourceEnv.AKAN_PUBLIC_APP_NAME;
+    const workspaceRoot = sourceEnv.AKAN_WORKSPACE_ROOT;
+    const workspaceId = sourceEnv.AKAN_WORKSPACE_ID;
+    const repoName = sourceEnv.AKAN_PUBLIC_REPO_NAME;
+    if (!repoName)
+      throw new Error("AKAN_PUBLIC_REPO_NAME is not set");
+    const serveDomain = sourceEnv.AKAN_PUBLIC_SERVE_DOMAIN;
+    if (!serveDomain)
+      throw new Error("AKAN_PUBLIC_SERVE_DOMAIN is not set");
+    const portOffset = parseInt(sourceEnv.PORT_OFFSET ?? "0");
+    const env = sourceEnv.AKAN_PUBLIC_ENV ?? "debug";
+    if (!env)
+      throw new Error("AKAN_PUBLIC_ENV is not set");
+    return {
+      ...appName ? { appName } : {},
+      workspaceRoot,
+      repoName,
+      serveDomain,
+      env,
+      portOffset,
+      workspaceId
+    };
+  }
+  getWorkspaceId({
+    allowEmpty
+  } = {}) {
+    const { workspaceId } = WorkspaceExecutor.getBaseDevEnv();
+    if (!workspaceId && !allowEmpty)
+      throw new Error("Workspace ID is not found");
+    return workspaceId;
+  }
+  async scan() {
+    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() {
+    const [appNames, libNames] = await Promise.all([this.getApps(), this.getLibs()]);
+    return [appNames, libNames];
+  }
+  async getPkgs() {
+    if (!await FileSys.dirExists(`${this.workspaceRoot}/pkgs`))
+      return [];
+    return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
+  }
+  async getExecs() {
+    const [appNames, libNames, pkgNames] = await Promise.all([this.getApps(), this.getLibs(), this.getPkgs()]);
+    return [appNames, libNames, pkgNames];
+  }
+  async setPkgTsPaths(name) {
+    const rootTsConfig = await this.readJson("tsconfig.json");
+    rootTsConfig.compilerOptions.paths ??= {};
+    rootTsConfig.compilerOptions.paths[name] = [`./pkgs/${name}/index.ts`];
+    rootTsConfig.compilerOptions.paths[`${name}/*`] = [`./pkgs/${name}/*`];
+    if (rootTsConfig.references) {
+      if (!rootTsConfig.references.some((ref) => ref.path === `./pkgs/${name}/tsconfig.json`))
+        rootTsConfig.references.push({ path: `./pkgs/${name}/tsconfig.json` });
+    }
+    await this.writeJson("tsconfig.json", rootTsConfig);
+    return this;
+  }
+  async unsetPkgTsPaths(name) {
+    const rootTsConfig = await this.readJson("tsconfig.json");
+    const filteredKeys = Object.keys(rootTsConfig.compilerOptions.paths ?? {}).filter((key) => key !== name && key !== `${name}/*`);
+    rootTsConfig.compilerOptions.paths = Object.fromEntries(filteredKeys.map((key) => [key, rootTsConfig.compilerOptions.paths?.[key] ?? []]));
+    if (rootTsConfig.references) {
+      rootTsConfig.references = rootTsConfig.references.filter((ref) => ref.path !== `./pkgs/${name}/tsconfig.json`);
+    }
+    await this.writeJson("tsconfig.json", rootTsConfig);
+    return this;
+  }
+  async getDirInModule(basePath, name) {
+    const AVOID_DIRS = ["__lib", "__scalar", `_`, `_${name}`];
+    const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
+      const dirs = await this.readdir(dirname);
+      await Promise.all(dirs.map(async (dir) => {
+        if (dir.includes("_") || AVOID_DIRS.includes(dir))
+          return;
+        const dirPath = path5.join(dirname, dir);
+        if ((await stat(dirPath)).isDirectory()) {
+          results.push(`${prefix}${dir}`);
+          if (maxDepth > 0)
+            await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
+        }
+      }));
+      return results;
+    };
+    return await getDirs(basePath);
+  }
+  async commit(message, { init = false, add = true } = {}) {
+    if (init)
+      await this.exec(`git init --quiet`);
+    if (add)
+      await this.exec(`git add .`);
+    await this.exec(`git commit --quiet -m "${message}"`);
+  }
+  async#getDirHasFile(basePath, targetFilename) {
+    const AVOID_DIRS = ["node_modules", "dist", "public", "webkit"];
+    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 = path5.join(dirname, dir);
+        if ((await stat(dirPath)).isDirectory()) {
+          const hasTargetFile = await FileSys.fileExists(path5.join(dirPath, targetFilename));
+          if (hasTargetFile)
+            results.push(`${prefix}${dir}`);
+          if (maxDepth > 0)
+            await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
+        }
+      }));
+      return results;
+    };
+    return await getDirs(basePath);
+  }
+  async getScalarConstantFiles() {
+    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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+}
+var scanFacetDirs = ["ui", "webkit", "srvkit", "common", "plugin"];
+
+class SysExecutor extends Executor {
+  workspace;
+  name;
+  type;
+  emoji;
+  constructor({ workspace = WorkspaceExecutor.fromRoot(), name, type }) {
+    super(name, `${workspace.workspaceRoot}/${type}s/${name}`);
+    this.workspace = workspace;
+    this.name = name;
+    this.type = type;
+    this.emoji = execEmoji[type];
+  }
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = this.type === "app" ? await AkanAppConfig.from(this) : await AkanLibConfig.from(this);
+    return this.#akanConfig;
+  }
+  async getModules() {
+    const path6 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
+    return await this.workspace.getDirInModule(path6, this.name);
+  }
+  #scanInfo = null;
+  hasScanInfo() {
+    return this.#scanInfo !== null;
+  }
+  getScanInfo({
+    allowEmpty
+  } = {}) {
+    if (!this.hasScanInfo() && !allowEmpty)
+      throw new Error("Scan info is not available");
+    return this.#scanInfo;
+  }
+  #getScanTemplateTasks(scanInfo) {
+    return [
+      this._applyTemplate({ basePath: "env", template: "env", scanInfo }),
+      this._applyTemplate({ basePath: "lib", template: "lib", scanInfo }),
+      this._applyTemplate({ basePath: ".", template: "server.ts", scanInfo }),
+      this._applyTemplate({ basePath: ".", template: "client.ts", scanInfo }),
+      this.type === "lib" ? this._applyTemplate({ basePath: ".", template: "index.ts", scanInfo }) : null,
+      ...scanFacetDirs.map((facet) => this._applyTemplate({
+        basePath: facet,
+        template: "facetIndex/index.ts",
+        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) }
+      }))
+    ];
+  }
+  async scan({
+    refresh = false,
+    write = true,
+    writeLib = write
+  } = {}) {
+    if (this.#scanInfo && !refresh)
+      return this.#scanInfo;
+    const scanInfo = this.type === "app" ? await AppInfo.fromExecutor(this, {
+      refresh
+    }) : await LibInfo.fromExecutor(this, {
+      refresh
+    });
+    if (write) {
+      await Promise.all(this.#getScanTemplateTasks(scanInfo));
+      await this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
+      if (this.type === "lib")
+        this.#updateDependencies(scanInfo);
+      if (writeLib) {
+        const libInfos = [...scanInfo.getLibInfos().values()];
+        await this.#updateDependencies(scanInfo);
+        await Promise.all(libInfos.flatMap((libInfo) => libInfo.exec.#getScanTemplateTasks(libInfo)));
+      }
+    }
+    this.#scanInfo = scanInfo;
+    return scanInfo;
+  }
+  async#updateDependencies(scanInfo) {
+    const rootPackageJson = await this.workspace.getPackageJson();
+    const libPackageJson = await this.getPackageJson();
+    const dependencies = scanInfo.getScanResult().dependencies;
+    const devDependencies = scanInfo.getScanResult().devDependencies;
+    const dependencySet = new Set(dependencies);
+    const devDependencySet = new Set(devDependencies);
+    const libPkgJsonWithDeps = {
+      ...libPackageJson,
+      dependencies: {
+        ...Object.fromEntries(Object.entries(libPackageJson.dependencies ?? {}).filter(([dep]) => !devDependencySet.has(dep))),
+        ...Object.fromEntries(dependencies.filter((dep) => rootPackageJson.dependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.dependencies?.[dep]]))
+      },
+      devDependencies: {
+        ...Object.fromEntries(Object.entries(libPackageJson.devDependencies ?? {}).filter(([dep]) => !dependencySet.has(dep))),
+        ...Object.fromEntries(devDependencies.filter((dep) => rootPackageJson.dependencies?.[dep] || rootPackageJson.devDependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.devDependencies?.[dep] ?? rootPackageJson.dependencies?.[dep]]))
+      }
+    };
+    await this.setPackageJson(libPkgJsonWithDeps);
+  }
+  async getLocalFile(targetPath) {
+    const filePath = path5.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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+  }
+  async getViewsSourceCode() {
+    const viewComponents = await this.getViewComponents();
+    return Promise.all(viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`)));
+  }
+  async getUnitsSourceCode() {
+    const unitComponents = await this.getUnitComponents();
+    return Promise.all(unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`)));
+  }
+  async getTemplatesSourceCode() {
+    const templateComponents = await this.getTemplateComponents();
+    return Promise.all(templateComponents.map((templateComponent) => this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`)));
+  }
+  async getScalarConstantFiles() {
+    const scalarModules = await this.getScalarModules();
+    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/__scalar/${scalarModule}/${scalarModule}.constant.ts`)));
+  }
+  async getScalarDictionaryFiles() {
+    const scalarModules = await this.getScalarModules();
+    return Promise.all(scalarModules.map((scalarModule) => this.getLocalFile(`lib/${scalarModule}/${scalarModule}.dictionary.ts`)));
+  }
+  async getConstantFiles() {
+    const modules = await this.getModules();
+    return Promise.all(modules.map((module) => this.getLocalFile(`lib/${module}/${module}.constant.ts`)));
+  }
+  async getConstantFilesWithLibs() {
+    const scanInfo = this.type === "app" ? await AppInfo.fromExecutor(this) : await LibInfo.fromExecutor(this);
+    const sysContantFiles = await this.getConstantFiles();
+    const sysScalarConstantFiles = await this.getScalarConstantFiles();
+    const libDeps = scanInfo.getLibs();
+    const libConstantFiles = await Promise.all(libDeps.map(async (lib) => [
+      ...await LibExecutor.from(this, lib).getConstantFiles(),
+      ...await LibExecutor.from(this, lib).getScalarConstantFiles()
+    ]));
+    return [...sysContantFiles, ...sysScalarConstantFiles, ...libConstantFiles.flat()];
+  }
+  async getDictionaryFiles() {
+    const modules = await this.getModules();
+    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
+    });
+    await this.scan();
+    return fileContents;
+  }
+}
+
+class AppExecutor extends SysExecutor {
+  static #routeSourceValidator = null;
+  static async#getRouteSourceValidator() {
+    AppExecutor.#routeSourceValidator ??= (await import("./routeSourceValidator-wbhmbwpj.js")).RouteSourceValidator;
+    return AppExecutor.#routeSourceValidator;
+  }
+  dist;
+  emoji = execEmoji.app;
+  constructor({ workspace, name }) {
+    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 exec2 = AppExecutor.#execs.get(name);
+    if (exec2)
+      return exec2;
+    else if (executor instanceof WorkspaceExecutor)
+      return new AppExecutor({ workspace: executor, name });
+    else
+      return new AppExecutor({ workspace: executor.workspace, name });
+  }
+  getEnv() {
+    return WorkspaceExecutor.getBaseDevEnv().env;
+  }
+  async getDevPort() {
+    const basePort = 8282;
+    const appNames = (await this.workspace.getApps()).sort((a, b) => a.localeCompare(b));
+    const appIndex = Math.max(appNames.indexOf(this.name), 0);
+    const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
+    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;
+    return {
+      ...process.env,
+      AKAN_PUBLIC_APP_NAME: this.name,
+      AKAN_WORKSPACE_ROOT: this.workspace.workspaceRoot,
+      NODE_NO_WARNINGS: "1",
+      PORT,
+      AKAN_PUBLIC_CLIENT_PORT: PORT,
+      ...AKAN_PUBLIC_SERVER_PORT ? { AKAN_PUBLIC_SERVER_PORT } : {},
+      ...env
+    };
+  }
+  async prepareCommand(type) {
+    const akanConfig2 = await this.getConfig();
+    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig2.defaultDatabaseMode ?? "single";
+    const routeEnv = {
+      AKAN_PUBLIC_BASE_PATHS: [...akanConfig2.basePaths].join(","),
+      AKAN_DATABASE_MODE: databaseMode
+    };
+    Object.assign(process.env, routeEnv);
+    if (type === "build") {
+      if (await this.exists(this.dist.cwdPath))
+        await this.dist.exec(`rm -rf ${this.dist.cwdPath}`);
+      await Promise.all([this.dist.mkdir("private"), this.dist.mkdir("public")]);
+      await Promise.all([
+        this.cp("private", `${this.dist.cwdPath}/private`),
+        this.cp("public", `${this.dist.cwdPath}/public`)
+      ]);
+    } else
+      await this.removeDir(".akan");
+    const devPort = type === "start" ? (await this.getDevPort()).toString() : undefined;
+    const env = this.getCommandEnv({
+      AKAN_COMMAND_TYPE: type,
+      ...routeEnv,
+      ...devPort ? { PORT: devPort, AKAN_PUBLIC_CLIENT_PORT: devPort, AKAN_PUBLIC_SERVER_PORT: devPort } : {}
+    });
+    if (type === "build")
+      Object.assign(process.env, env);
+    return { env };
+  }
+  #publicEnv = null;
+  getPublicEnv(...patterns) {
+    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 publicEnv = {};
+    for (const [k, v] of Object.entries(process.env)) {
+      if (typeof v !== "string")
+        continue;
+      if (regexes.some((r) => r.test(k)))
+        publicEnv[k] = v;
+    }
+    this.#publicEnv = publicEnv;
+    return publicEnv;
+  }
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = await AkanAppConfig.from(this, { bustImportCache: refresh });
+    return this.#akanConfig;
+  }
+  #pageKeys = null;
+  async getPageKeys({ refresh } = {}) {
+    if (this.#pageKeys && !refresh)
+      return this.#pageKeys;
+    const akanConfig2 = await this.getConfig();
+    const glob = new Bun.Glob("**/*");
+    const pageKeys = [];
+    const pageDir = `${this.cwdPath}/page`;
+    if (!await FileSys.dirExists(pageDir)) {
+      this.#pageKeys = [];
+      return this.#pageKeys;
+    }
+    for await (const rel of glob.scan({
+      cwd: pageDir,
+      absolute: false,
+      onlyFiles: true
+    })) {
+      const segments = rel.split(path5.sep);
+      if (segments.some((s) => s === "node_modules"))
+        continue;
+      const posix = segments.join("/");
+      const absPath = path5.join(pageDir, posix);
+      validatePageSourceFile(posix, { filePath: absPath });
+      if (!isRouteSourceFile(posix))
+        continue;
+      const key = `./${posix}`;
+      validateSubRoutePageKey(key, akanConfig2.basePaths, {
+        appName: this.name,
+        filePath: absPath
+      });
+      const parsed = parseRouteModuleKey(key);
+      if (parsed.isInternalRootLayout) {
+        throw new Error(`[route-convention] __root_layout is reserved for Akan.js generated root layout: ${absPath}`);
+      }
+      const isRootLayout = parsed.kind === "layout" && parsed.moduleSegments.at(-1) === "_layout";
+      const routeSource = await Bun.file(absPath).text();
+      const validator = await AppExecutor.#getRouteSourceValidator();
+      if (parsed.kind === "overrides")
+        validator.validateOverridesSourceExports(routeSource, absPath);
+      else
+        validator.validateRouteSourceExports(routeSource, absPath, parsed.kind, { rootLayout: isRootLayout });
+      pageKeys.push(key);
+    }
+    pageKeys.sort();
+    this.#pageKeys = pageKeys;
+    return this.#pageKeys;
+  }
+  setPageKeys(pageKeys) {
+    this.#pageKeys = pageKeys;
+  }
+  async syncAssets(libDeps) {
+    const projectPublicPath = `${this.cwdPath}/public`;
+    const projectAssetsPath = `${this.cwdPath}/private`;
+    const projectPublicLibPath = `${projectPublicPath}/libs`;
+    const projectAssetsLibPath = `${projectAssetsPath}/libs`;
+    await Promise.all([this.removeDir(projectPublicLibPath), this.removeDir(projectAssetsLibPath)]);
+    const targetPublicDeps = [];
+    for (const dep of libDeps) {
+      if (await this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/public`))
+        targetPublicDeps.push(dep);
+    }
+    const targetAssetsDeps = [];
+    for (const dep of libDeps) {
+      if (await this.exists(`${this.workspace.workspaceRoot}/libs/${dep}/private`))
+        targetAssetsDeps.push(dep);
+    }
+    await Promise.all(targetPublicDeps.map((dep) => this.mkdir(`${projectPublicLibPath}/${dep}`)));
+    await Promise.all(targetAssetsDeps.map((dep) => this.mkdir(`${projectAssetsLibPath}/${dep}`)));
+    await Promise.all([
+      ...targetPublicDeps.map((dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`)),
+      ...targetAssetsDeps.map((dep) => this.cp(`${this.workspace.workspaceRoot}/libs/${dep}/private`, `${projectAssetsLibPath}/${dep}`))
+    ]);
+  }
+  async scanSync({ refresh = false, write = true } = {}) {
+    const scanInfo = await this.scan({
+      refresh,
+      write,
+      writeLib: write
+    });
+    if (write)
+      await this.syncAssets(scanInfo.getScanResult().libDeps);
+    if (write)
+      await this.#runPluginSyncAssets();
+    return scanInfo;
+  }
+  async#runPluginSyncAssets() {
+    const plugins = await this.collectPlugins();
+    if (!plugins.some((plugin) => plugin.syncAssets))
+      return;
+    const ctx = this.#makeSyncContext();
+    for (const plugin of plugins)
+      await plugin.syncAssets?.(ctx);
+  }
+  #makeSyncContext() {
+    return {
+      appName: this.name,
+      appPath: this.cwdPath,
+      executor: this,
+      getPath: (rel) => this.getPath(rel),
+      fileExists: (rel) => FileSys.fileExists(this.getPath(rel)),
+      writeFile: async (rel, content, opts) => {
+        await this.writeFile(rel, content, opts);
+      },
+      readEnvClient: async () => {
+        const envClientPath = path5.join(this.cwdPath, "env", "env.client.ts");
+        if (!await FileSys.fileExists(envClientPath))
+          return null;
+        try {
+          const envUrl = pathToFileURL(envClientPath);
+          envUrl.searchParams.set("t", String(Date.now()));
+          const envModule = await import(envUrl.href);
+          return envModule.env ?? null;
+        } catch {
+          return null;
+        }
+      }
+    };
+  }
+  async collectPlugins() {
+    const scanInfo = await this.scan({ write: false });
+    const libDeps = scanInfo.getLibs();
+    const appConfig = await this.getConfig();
+    const collected = [...appConfig.plugins];
+    for (const libName of libDeps) {
+      const libConfig = await LibExecutor.from(this, libName).getConfig().catch(() => null);
+      if (libConfig)
+        collected.push(...libConfig.plugins);
+    }
+    const seen = new Set;
+    return collected.filter((plugin) => {
+      if (seen.has(plugin.name))
+        return false;
+      seen.add(plugin.name);
+      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);
+  }
+  async decreaseBuildNum() {
+    await decreaseBuildNum(this);
+  }
+}
+
+class LibExecutor extends SysExecutor {
+  dist;
+  emoji = execEmoji.lib;
+  constructor({ workspace, name }) {
+    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 exec2 = LibExecutor.#execs.get(name);
+    if (exec2)
+      return exec2;
+    else if (executor instanceof WorkspaceExecutor)
+      return new LibExecutor({ workspace: executor, name });
+    else
+      return new LibExecutor({ workspace: executor.workspace, name });
+  }
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = await AkanLibConfig.from(this);
+    return this.#akanConfig;
+  }
+}
+
+class PkgExecutor extends Executor {
+  workspace;
+  name;
+  dist;
+  emoji = execEmoji.pkg;
+  constructor({ workspace = WorkspaceExecutor.fromRoot(), name }) {
+    super(name, `${workspace.workspaceRoot}/pkgs/${name}`);
+    this.workspace = workspace;
+    this.name = name;
+    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 });
+  }
+  #scanInfo = null;
+  async scan({ refresh } = {}) {
+    if (this.#scanInfo && !refresh)
+      return this.#scanInfo;
+    const scanInfo = await PkgInfo.fromExecutor(this, { refresh });
+    this.#scanInfo = scanInfo;
+    return scanInfo;
+  }
+  async#getDependencyVersion(rootPackageJson, dep) {
+    const rootDeps = {
+      ...rootPackageJson.dependencies,
+      ...rootPackageJson.devDependencies
+    };
+    const rootVersion = rootDeps[dep];
+    if (rootVersion)
+      return rootVersion;
+    try {
+      const packageJsonPath = `pkgs/${dep}/package.json`;
+      if (!await Bun.file(path5.join(this.workspace.workspaceRoot, packageJsonPath)).exists())
+        return;
+      const packageJson = await this.workspace.readJson(packageJsonPath);
+      if (packageJson.name === dep)
+        return packageJson.version;
+    } catch {
+      return;
+    }
+  }
+  async#toDependencyMap(rootPackageJson, dependencies = [], devDependencies = []) {
+    const dependencyNames = [...new Set(dependencies)].sort();
+    const devDependencyNames = [...new Set(devDependencies)].filter((dep) => !dependencyNames.includes(dep)).sort();
+    const dependencyVersions = new Map;
+    const missingDeps = [];
+    for (const dep of [...dependencyNames, ...devDependencyNames]) {
+      const version = await this.#getDependencyVersion(rootPackageJson, dep);
+      if (version)
+        dependencyVersions.set(dep, version);
+      else
+        missingDeps.push(dep);
+    }
+    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))
+    };
+  }
+  async updatePackageJsonDependencies(dependencies = [], devDependencies = []) {
+    const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
+    const dependencyMaps = await this.#toDependencyMap(rootPackageJson, dependencies, devDependencies);
+    const newPkgJson = {
+      ...pkgJson,
+      ...dependencyMaps
+    };
+    await this.writeJson("package.json", newPkgJson);
+    return newPkgJson;
+  }
+  async generateDistPackageJson(dependencies = [], devDependencies = []) {
+    const [rootPackageJson, pkgJson] = await Promise.all([this.workspace.getPackageJson(), this.getPackageJson()]);
+    const dependencyMaps = await this.#toDependencyMap(rootPackageJson, dependencies, devDependencies);
+    const distPkgJson = {
+      ...pkgJson,
+      type: "module",
+      exports: {
+        ...pkgJson.exports,
+        ".": {
+          import: "./index.ts",
+          types: "./index.ts",
+          default: "./index.ts"
+        }
+      },
+      engines: { bun: ">=1.3.13" },
+      ...dependencyMaps
+    };
+    await Promise.all([this.dist.writeJson("package.json", distPkgJson), this.writeJson("package.json", distPkgJson)]);
+    return distPkgJson;
+  }
+  async build() {
+    await Bun.build({
+      root: this.cwdPath,
+      entrypoints: [`${this.cwdPath}/index.ts`],
+      splitting: false,
+      target: "bun"
+    });
+    await this.cp(`${this.cwdPath}/dist`, this.dist.cwdPath);
+  }
+  async generateTsconfigJson() {
+    const [rootTsconfig, pkgTsconfig] = await Promise.all([this.workspace.getTsConfig(), this.getTsConfig()]);
+    const tsconfig = {
+      ...rootTsconfig,
+      ...pkgTsconfig,
+      compilerOptions: {
+        ...rootTsconfig.compilerOptions,
+        ...pkgTsconfig.compilerOptions,
+        paths: {}
+      }
+    };
+    await this.dist.writeJson("tsconfig.json", tsconfig);
+    return tsconfig;
+  }
+}
+
+class ModuleExecutor extends Executor {
+  sys;
+  emoji = execEmoji.module;
+  constructor({ sys, name }) {
+    super(name, `${sys.workspace.workspaceRoot}/${sys.type}s/${sys.name}/lib/${name}`);
+    this.sys = sys;
+  }
+  static from(sysExecutor, name) {
+    return new ModuleExecutor({ sys: sysExecutor, name });
+  }
+}
+
+export { getDirname, CommandExecutionError, Executor, WorkspaceExecutor, AppExecutor, LibExecutor, PkgExecutor, ModuleExecutor };