@akanjs/cli 2.4.0-rc.9 → 2.4.1-rc.0

package/index-9sp6fsc5.js

@@ -0,0 +1,1884 @@
+// @bun
+import {
+  resolveMobileTargets
+} from "./index-76rn3g2c.js";
+import {
+  LibraryScript
+} from "./index-pmm9e2jf.js";
+import {
+  runner,
+  script
+} from "./index-hdqztm58.js";
+import {
+  AppExecutor,
+  LibExecutor,
+  PkgExecutor,
+  WorkspaceExecutor
+} from "./index-a6sbyy0b.js";
+import {
+  __require
+} from "./index-r24hmh0q.js";
+
+// pkgs/@akanjs/devkit/applicationBuildReporter.ts
+import { Logger } from "akanjs/common";
+
+class ApplicationBuildReporter {
+  static create() {
+    return {
+      phaseDone: (phase) => Logger.rawLog(ApplicationBuildReporter.formatPhaseLine(phase))
+    };
+  }
+  static printSummary(result) {
+    Logger.rawLog("");
+    Logger.rawLog(`Route artifacts: ${result.artifactDir}`);
+    Logger.rawLog(`Server output: ${result.outputDir}`);
+    Logger.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
+  }
+  static formatError(error) {
+    if (error instanceof AggregateError) {
+      const nestedMessages = error.errors.map((nestedError, index) => ApplicationBuildReporter.formatError(nestedError).trim() || `Unknown error ${index + 1}`).map((message) => message.replace(/^/gm, "  ")).join(`
+`);
+      return nestedMessages ? `${error.message}
+${nestedMessages}` : error.message;
+    }
+    if (error instanceof Error) {
+      const causeMessage = error.cause ? `
+Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
+      return `${error.message}${causeMessage}`;
+    }
+    if (typeof error === "object" && error !== null && "message" in error)
+      return String(error.message);
+    return String(error);
+  }
+  static formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${Math.round(ms / 100) / 10}s`;
+    const seconds = Math.floor(ms / 1000);
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  }
+  static formatPhaseLine(phase) {
+    const summary = phase.summary ? `: ${phase.summary}` : "";
+    return `\u2713 ${phase.label}${summary} (${ApplicationBuildReporter.formatDuration(phase.durationMs)})`;
+  }
+}
+
+// pkgs/@akanjs/cli/application/application.script.ts
+import { confirm } from "@inquirer/prompts";
+import { Logger as Logger5 } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
+import path2 from "path";
+import { Logger as Logger3 } from "akanjs/common";
+
+// pkgs/@akanjs/devkit/sshTunnel.ts
+import { Client } from "ssh2";
+var closeQuietly = (close) => {
+  try {
+    close();
+  } catch {}
+};
+var createSshClient = async (options) => new Promise((resolve, reject) => {
+  const client = new Client;
+  const cleanup = () => {
+    client.off("ready", onReady);
+    client.off("error", onError);
+    client.off("close", onClose);
+  };
+  const onReady = () => {
+    cleanup();
+    resolve(client);
+  };
+  const onError = (error) => {
+    cleanup();
+    reject(error);
+  };
+  const onClose = () => {
+    cleanup();
+    reject(new Error("SSH tunnel closed before it was ready"));
+  };
+  client.once("ready", onReady);
+  client.once("error", onError);
+  client.once("close", onClose);
+  client.connect({ readyTimeout: 1e4, ...options.sshOptions });
+});
+var createSshTunnel = async (options) => {
+  const client = await createSshClient(options);
+  const sockets = new Set;
+  let closing = false;
+  const closeSocket = (socket, error) => {
+    sockets.delete(socket);
+    closeBunSocket(socket, error);
+  };
+  try {
+    const server = Bun.listen({
+      hostname: options.localHost ?? "127.0.0.1",
+      port: options.localPort,
+      socket: {
+        open(socket) {
+          sockets.add(socket);
+          socket.data = { pending: [], closed: false };
+          client.forwardOut(options.srcHost ?? "127.0.0.1", options.srcPort ?? options.localPort, options.dstHost, options.dstPort, (error, stream) => {
+            if (error) {
+              closeSocket(socket, error);
+              return;
+            }
+            if (socket.data.closed) {
+              stream.destroy();
+              return;
+            }
+            socket.data.stream = stream;
+            stream.on("data", (chunk) => socket.write(chunk));
+            stream.once("close", () => closeSocket(socket));
+            stream.once("error", (streamError) => closeSocket(socket, streamError));
+            for (const chunk of socket.data.pending)
+              stream.write(chunk);
+            socket.data.pending = [];
+          });
+        },
+        data(socket, chunk) {
+          const buffer = Buffer.from(chunk);
+          if (socket.data.stream)
+            socket.data.stream.write(buffer);
+          else
+            socket.data.pending.push(buffer);
+        },
+        close(socket) {
+          closeSocket(socket);
+        },
+        error(socket, error) {
+          closeSocket(socket, error);
+        }
+      }
+    });
+    const closeTunnel = (error) => {
+      if (closing)
+        return;
+      closing = true;
+      for (const socket of sockets)
+        closeSocket(socket, error);
+      closeQuietly(() => client.end());
+      closeBunServer(server);
+    };
+    client.once("error", (error) => closeTunnel(error));
+    client.once("close", () => closeTunnel());
+    return { close: closeTunnel };
+  } catch (error) {
+    closeQuietly(() => client.end());
+    throw error;
+  }
+};
+var closeBunSocket = (socket, error) => {
+  if (socket.data.closed)
+    return;
+  socket.data.closed = true;
+  if (error)
+    socket.data.stream?.destroy();
+  else
+    socket.data.stream?.end();
+  closeQuietly(() => socket.end());
+};
+var closeBunServer = (server) => {
+  server.stop();
+};
+
+// pkgs/@akanjs/devkit/createTunnel.ts
+var getSshTunnelOptions = (app, environment) => {
+  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
+  return {
+    host: `${app.name}-${environment}.${serveDomain}`,
+    port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
+    username: process.env.SSH_TUNNEL_USERNAME ?? "root",
+    password: process.env.SSH_TUNNEL_PASSWORD ?? repoName
+  };
+};
+var createTunnel = async (service, { app, environment, port = service === "postgres" ? 5432 : 6379 }) => {
+  const sshOptions = getSshTunnelOptions(app, environment);
+  await createSshTunnel({
+    localHost: "0.0.0.0",
+    localPort: port,
+    srcHost: "0.0.0.0",
+    srcPort: port,
+    dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
+    dstPort: service === "postgres" ? 5432 : 6379,
+    sshOptions
+  });
+  return `localhost:${port}`;
+};
+// pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
+import path from "path";
+import { Logger as Logger2 } from "akanjs/common";
+var builderMsgTypeSet = new Set([
+  "build-route-res",
+  "build-csr-res",
+  "builder-ready",
+  "invalidate",
+  "css-updated",
+  "pages-updated",
+  "build-status"
+]);
+
+class IncrementalBuilderHost {
+  static #restartBaseDelayMs = 1000;
+  static #restartMaxDelayMs = 30000;
+  logger = new Logger2("IncrementalBuilderHost");
+  entry;
+  env;
+  app;
+  ready = false;
+  #onMessage;
+  #proc = null;
+  #status = "stopped";
+  #restartAttempts = 0;
+  #restartTimer = null;
+  #manualStop = false;
+  #startOptions = {};
+  constructor({ app, entry, env, onMessage }) {
+    this.app = app;
+    this.entry = entry;
+    this.env = env;
+    this.#onMessage = onMessage;
+  }
+  get status() {
+    return this.#status;
+  }
+  start(options = {}) {
+    if (this.#proc)
+      this.stop();
+    this.#manualStop = false;
+    this.#startOptions = options;
+    this.#spawn(false);
+    return this;
+  }
+  #spawn(isRestart) {
+    this.#status = isRestart ? "restarting" : "starting";
+    this.ready = false;
+    let proc;
+    proc = Bun.spawn(["bun", this.entry], {
+      cwd: this.app.cwdPath,
+      env: { ...this.env, AKAN_WATCH: "1" },
+      stdio: ["ignore", "inherit", "inherit"],
+      ipc: (msg) => {
+        if (this.#proc !== proc)
+          return;
+        if (!msg || typeof msg !== "object")
+          return;
+        if (builderMsgTypeSet.has(msg.type))
+          this.#onMessage(msg);
+        if (msg.type === "builder-ready" && !this.ready) {
+          this.ready = true;
+          this.#status = "ready";
+          this.#restartAttempts = 0;
+          if (isRestart)
+            this.#startOptions.onRestartReady?.();
+          else
+            this.#startOptions.onReady?.();
+        }
+      },
+      serialization: "advanced",
+      onExit: () => {
+        if (this.#proc !== proc)
+          return;
+        this.#proc = null;
+        const wasReady = this.ready;
+        this.ready = false;
+        if (this.#manualStop || this.#status === "stopped")
+          return;
+        if (!wasReady) {
+          this.#status = "stopped";
+          this.#startOptions.onExit?.();
+          return;
+        }
+        this.#scheduleRestart();
+      }
+    });
+    this.#proc = proc;
+    this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
+  }
+  #scheduleRestart() {
+    if (this.#manualStop || this.#restartTimer)
+      return;
+    this.#status = "restarting";
+    const attempt = this.#restartAttempts;
+    const delay = Math.min(IncrementalBuilderHost.#restartBaseDelayMs * 2 ** attempt, IncrementalBuilderHost.#restartMaxDelayMs);
+    this.#restartAttempts = attempt + 1;
+    this.logger.warn(`builder exited after ready; restarting in ${delay}ms (attempt ${this.#restartAttempts})`);
+    this.#restartTimer = setTimeout(() => {
+      this.#restartTimer = null;
+      if (this.#manualStop)
+        return;
+      this.#spawn(true);
+    }, delay);
+  }
+  send(message) {
+    if (!this.#proc || this.#status !== "ready") {
+      this.logger.warn(`incrementalBuilderHost is ${this.#status}; cannot send ${message.type}`);
+      return false;
+    }
+    try {
+      this.#proc.send(message);
+      return true;
+    } catch (error) {
+      this.logger.warn(`failed to send ${message.type} to builder: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+  stop() {
+    this.#manualStop = true;
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
+    if (this.#proc)
+      this.#proc.kill();
+    this.#proc = null;
+    this.ready = false;
+    this.#status = "stopped";
+  }
+  static async create(app, env, onMessage) {
+    const candidates = [
+      path.join(app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
+      path.join(app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
+      path.join(import.meta.dir, "incrementalBuilder.proc.js"),
+      path.join(import.meta.dir, "incrementalBuilder.proc.ts")
+    ];
+    for (const c of candidates)
+      if (await Bun.file(c).exists())
+        return new IncrementalBuilderHost({ app, entry: c, env, onMessage });
+    throw new Error(`[cli] frontend builder entry not found; looked in: ${candidates.join(", ")}`);
+  }
+}
+// pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
+var backendMsgTypeSet = new Set(["build-route", "build-csr"]);
+var BACKEND_RESTART_DEBOUNCE_MS = 120;
+var BACKEND_GRACEFUL_TIMEOUT_MS = 8000;
+var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
+var BACKEND_RECOVERY_MAX_DELAY_MS = 30000;
+var BACKEND_RECOVERY_MAX_ATTEMPTS = 5;
+var BACKEND_STDERR_TAIL_LIMIT = 40;
+var BUILDER_READY_TIMEOUT_MS = 150000;
+var BUILDER_START_MAX_ATTEMPTS = 3;
+var BUILDER_RECOVERY_BASE_DELAY_MS = 2000;
+var BUILDER_RECOVERY_MAX_DELAY_MS = 60000;
+var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav|html)$/i;
+var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+var GRAPH_IMPORT_KINDS = new Set([
+  "import-statement",
+  "require-call",
+  "require-resolve",
+  "dynamic-import"
+]);
+var shouldRestartBackendByDevPlan = (message) => {
+  if (!message.devPlan)
+    return null;
+  if (message.devPlan.actions.includes("report-error"))
+    return false;
+  if (message.devPlan.actions.includes("restart-builder"))
+    return false;
+  return message.devPlan.actions.includes("restart-backend");
+};
+var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includes("restart-builder") ?? false;
+var shouldAbandonBackendRecovery = (attempts, maxAttempts = BACKEND_RECOVERY_MAX_ATTEMPTS) => attempts >= maxAttempts;
+var normalizeBackendReportedGeneration = (generation) => generation >= 0 ? generation : undefined;
+var shouldRestartDevHostByDevPlan = (message) => message.devPlan?.actions.includes("restart-dev-host") ?? message.kinds.includes("config");
+var RESTART_ROLE_ORDER = ["server", "shared", "barrel", "config"];
+var generationValue = (generation) => generation ?? -1;
+var isLegacyBackendFallbackFile = (file, workspaceRoot) => {
+  const abs = path2.resolve(file);
+  const ext = path2.extname(abs).toLowerCase();
+  if (!SOURCE_EXTS.has(ext))
+    return false;
+  const rel = path2.relative(path2.resolve(workspaceRoot), abs);
+  if (!rel || rel.startsWith("..") || path2.isAbsolute(rel))
+    return false;
+  const parts = rel.split(path2.sep).filter(Boolean);
+  const [scope] = parts;
+  if (scope !== "apps" && scope !== "libs" && scope !== "pkgs")
+    return false;
+  const base = path2.basename(abs);
+  return parts.includes("srvkit") || parts.includes("common") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base) || base === "main.ts" || base === "server.ts";
+};
+var shouldMarkBuildPhaseRecovered = (previousByPhase, status) => {
+  const previous = previousByPhase.get(status.phase);
+  return Boolean(previous && status.ok && !previous.ok && generationValue(status.generation) >= previous.generation);
+};
+var createBackendBuildStatus = ({
+  generation,
+  ok,
+  files = [],
+  message
+}) => ({
+  generation,
+  phase: "backend",
+  ok,
+  files,
+  message
+});
+var backendRestartReasonFromMessage = (message) => {
+  const roleSet = new Set;
+  for (const role of message.devPlan?.roles ?? []) {
+    if (role === "server" || role === "shared" || role === "barrel" || role === "config")
+      roleSet.add(role);
+  }
+  return {
+    generation: message.devPlan?.generation ?? message.generation,
+    files: [...new Set(message.files)].sort(),
+    roles: RESTART_ROLE_ORDER.filter((role) => roleSet.has(role))
+  };
+};
+var mergeBackendRestartReasons = (current, next) => ({
+  generation: generationValue(next.generation) >= generationValue(current?.generation) ? next.generation : current?.generation,
+  files: [...new Set([...current?.files ?? [], ...next.files])].sort(),
+  roles: RESTART_ROLE_ORDER.filter((role) => current?.roles.includes(role) || next.roles.includes(role))
+});
+var shouldReplaceLastGoodMessage = (current, next) => !current || generationValue(next.data.generation) >= generationValue(current.data.generation);
+var shouldQueueBuildStatusReplay = (backendReady, pendingReplayCount) => !backendReady || pendingReplayCount > 0;
+var hasBuildFailureForGeneration = (statusByPhase, generation) => {
+  if (typeof generation !== "number")
+    return false;
+  for (const status of statusByPhase.values()) {
+    if (!status.ok && status.generation === generation)
+      return true;
+  }
+  return false;
+};
+var mergeDevPlans = (current, next) => {
+  if (!current)
+    return next;
+  if (!next)
+    return current;
+  const reasonByFile = { ...current.reasonByFile };
+  for (const [file, reasons] of Object.entries(next.reasonByFile)) {
+    reasonByFile[file] = [...new Set([...reasonByFile[file] ?? [], ...reasons])].sort();
+  }
+  return {
+    generation: Math.max(current.generation, next.generation),
+    files: [...new Set([...current.files, ...next.files])].sort(),
+    generatedFiles: [...new Set([...current.generatedFiles, ...next.generatedFiles])].sort(),
+    roles: [...new Set([...current.roles, ...next.roles])].sort(),
+    actions: [...new Set([...current.actions, ...next.actions])].sort(),
+    reasonByFile
+  };
+};
+var mergeInvalidateMessages = (current, next) => {
+  const generation = Math.max(generationValue(current.generation), generationValue(next.generation));
+  return {
+    type: "invalidate",
+    kinds: [...new Set([...current.kinds, ...next.kinds])].sort(),
+    files: [...new Set([...current.files, ...next.files])].sort(),
+    generation: generation >= 0 ? generation : undefined,
+    devPlan: mergeDevPlans(current.devPlan, next.devPlan)
+  };
+};
+var buildStatusReplaySequence = (pendingReplay, latestByPhase) => [...pendingReplay, ...latestByPhase.values()];
+
+class BackendImportGraph {
+  #app;
+  #logger;
+  #tsTranspiler = new Bun.Transpiler({ loader: "ts" });
+  #tsxTranspiler = new Bun.Transpiler({ loader: "tsx" });
+  #jsTranspiler = new Bun.Transpiler({ loader: "js" });
+  #jsxTranspiler = new Bun.Transpiler({ loader: "jsx" });
+  #files = new Set;
+  #ready = false;
+  #lastRefreshSucceeded = false;
+  constructor(app, logger) {
+    this.#app = app;
+    this.#logger = logger;
+  }
+  get ready() {
+    return this.#ready;
+  }
+  get lastRefreshSucceeded() {
+    return this.#lastRefreshSucceeded;
+  }
+  has(file) {
+    return this.#files.has(path2.resolve(file));
+  }
+  async refresh() {
+    try {
+      const files = await this.#build();
+      this.#files = files;
+      this.#ready = true;
+      this.#lastRefreshSucceeded = true;
+      this.#logger.verbose(`[backend-graph] scanned ${files.size} files`);
+      return true;
+    } catch (err) {
+      this.#ready = this.#files.size > 0;
+      this.#lastRefreshSucceeded = false;
+      this.#logger.warn(`[backend-graph] scan failed; ${this.#ready ? "using previous graph" : "using fallback rules"}: ${err instanceof Error ? err.message : String(err)}`);
+      return this.#ready;
+    }
+  }
+  async#build() {
+    const roots = await this.#entrypoints();
+    const files = new Set;
+    const queue = [...roots];
+    const workspaceRoot = path2.resolve(this.#app.workspace.workspaceRoot);
+    while (queue.length > 0) {
+      const current = path2.resolve(queue.pop());
+      if (files.has(current))
+        continue;
+      if (!this.#isWorkspaceSource(current, workspaceRoot))
+        continue;
+      if (!await Bun.file(current).exists())
+        continue;
+      files.add(current);
+      const source = await Bun.file(current).text();
+      const imports = this.#scanImports(current, source);
+      const importerDir = path2.dirname(current);
+      for (const imp of imports) {
+        if (!GRAPH_IMPORT_KINDS.has(imp.kind) || !imp.path || NON_SOURCE_EXT_RE.test(imp.path))
+          continue;
+        const resolved = this.#resolve(imp.path, importerDir);
+        if (!resolved || files.has(resolved))
+          continue;
+        queue.push(resolved);
+      }
+    }
+    return files;
+  }
+  async#entrypoints() {
+    const roots = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
+    const existing = [];
+    for (const root of roots) {
+      const abs = path2.resolve(root);
+      if (await Bun.file(abs).exists())
+        existing.push(abs);
+    }
+    return existing;
+  }
+  #resolve(specifier, importerDir) {
+    try {
+      const resolved = Bun.resolveSync(specifier, importerDir);
+      if (!path2.isAbsolute(resolved))
+        return null;
+      if (!SOURCE_EXTS.has(path2.extname(resolved).toLowerCase()))
+        return null;
+      return path2.resolve(resolved);
+    } catch {
+      return null;
+    }
+  }
+  #isWorkspaceSource(file, workspaceRoot) {
+    const rel = path2.relative(workspaceRoot, file);
+    if (rel.startsWith("..") || path2.isAbsolute(rel))
+      return false;
+    if (rel.includes(`${path2.sep}node_modules${path2.sep}`) || rel.includes(`${path2.sep}.akan${path2.sep}`))
+      return false;
+    return SOURCE_EXTS.has(path2.extname(file).toLowerCase());
+  }
+  #scanImports(file, source) {
+    const ext = path2.extname(file).toLowerCase();
+    if (ext === ".tsx")
+      return this.#tsxTranspiler.scanImports(source);
+    if (ext === ".jsx")
+      return this.#jsxTranspiler.scanImports(source);
+    if (ext === ".js" || ext === ".mjs" || ext === ".cjs")
+      return this.#jsTranspiler.scanImports(source);
+    return this.#tsTranspiler.scanImports(source);
+  }
+}
+
+class AkanAppHost {
+  app;
+  logger = new Logger3("AkanAppHost");
+  withInk;
+  env;
+  #backend = null;
+  #builder = null;
+  #backendReady = false;
+  #plannedBackendStops = new WeakSet;
+  #restartTimer = null;
+  #backendRecoveryTimer = null;
+  #backendRecoveryAttempts = 0;
+  #backendGaveUp = false;
+  #backendLifecycleState = "stopped";
+  #pendingRestartReason = null;
+  #pendingRecycle = null;
+  #builderRecoveryTimer = null;
+  #builderRecoveryAttempts = 0;
+  #backendStartStatus = null;
+  #backendBuildStatusGeneration = 0;
+  #backendStderrTail = [];
+  #lastGoodFrontend = {};
+  #buildStatusByPhase = new Map;
+  #pendingBuildStatusReplay = [];
+  #builderMessageQueue = Promise.resolve();
+  #backendGraph;
+  constructor(app, { env, withInk = false }) {
+    this.app = app;
+    this.env = env;
+    this.withInk = withInk;
+    this.#backendGraph = new BackendImportGraph(app, this.logger);
+  }
+  async start() {
+    if (this.#backend)
+      await this.#stopBackend();
+    if (this.#builder)
+      this.#stopBuilder();
+    const [redisHost] = await Promise.all([
+      this.#prepareDatabase("redis"),
+      this.#backendGraph.refresh(),
+      this.#startBuilder()
+    ]);
+    Object.assign(this.env, { REDIS_HOST: redisHost });
+    this.#startBackend();
+    return this;
+  }
+  async stop() {
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
+    if (this.#builderRecoveryTimer) {
+      clearTimeout(this.#builderRecoveryTimer);
+      this.#builderRecoveryTimer = null;
+    }
+    await this.#stopBackend();
+    this.#stopBuilder();
+    return this;
+  }
+  kill() {
+    this.stop();
+  }
+  async#prepareDatabase(type) {
+    const environment = WorkspaceExecutor.getBaseDevEnv().env;
+    if (environment === "local")
+      return "localhost";
+    return await createTunnel(type, { app: this.app, environment });
+  }
+  #startBackend(startStatus = null) {
+    this.#backendStartStatus = startStatus;
+    this.#backendGaveUp = false;
+    this.#setBackendLifecycleState("starting");
+    this.#backendReady = false;
+    this.#backendStderrTail = [];
+    const backend = Bun.spawn(["bun", `apps/${this.app.name}/main.ts`], {
+      cwd: this.app.workspace.workspaceRoot,
+      stdio: this.withInk ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
+      env: this.env,
+      ipc: (msg) => {
+        if (!msg || typeof msg !== "object")
+          return;
+        if (msg.type === "backend-ready") {
+          this.#backendReady = true;
+          this.#backendRecoveryAttempts = 0;
+          this.#setBackendLifecycleState("ready", `pid=${msg.pid}`);
+          this.#recordBackendReadyStatus();
+          this.logger.verbose(`backend ready pid=${msg.pid}`);
+          this.#replayBuilderState();
+          return;
+        }
+        if (msg.type === "build-status") {
+          const status = this.#recordBackendBuildStatus({
+            generation: normalizeBackendReportedGeneration(msg.data.generation),
+            ok: msg.data.ok,
+            files: msg.data.files,
+            message: msg.data.message
+          });
+          this.#sendOrQueueBuildStatus(status);
+          return;
+        }
+        if (backendMsgTypeSet.has(msg.type))
+          this.#sendToBuilder(msg);
+      },
+      serialization: "advanced",
+      onExit: () => {
+        this.#backendReady = false;
+        if (this.#backend === backend)
+          this.#backend = null;
+        if (this.#plannedBackendStops.has(backend)) {
+          this.#plannedBackendStops.delete(backend);
+          return;
+        }
+        this.#scheduleBackendRecovery("backend-exit");
+      }
+    });
+    this.#backend = backend;
+    this.logger.verbose(`backend spawned pid=${backend.pid}`);
+    if (this.withInk) {
+      this.#forwardBackendStream(backend.stderr, "stderr");
+      this.#forwardBackendStream(backend.stdout, "stdout");
+    }
+  }
+  #recordBackendStderr(chunk) {
+    const lines = chunk.split(/\r?\n/).filter((line) => line.length > 0);
+    if (lines.length === 0)
+      return;
+    this.#backendStderrTail.push(...lines);
+    if (this.#backendStderrTail.length > BACKEND_STDERR_TAIL_LIMIT) {
+      this.#backendStderrTail.splice(0, this.#backendStderrTail.length - BACKEND_STDERR_TAIL_LIMIT);
+    }
+  }
+  async#forwardBackendStream(stream, kind) {
+    if (!stream)
+      return;
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        if (!text.trim())
+          continue;
+        if (kind === "stderr") {
+          this.#recordBackendStderr(text);
+          this.logger.warn(`[backend] ${text.trimEnd()}`);
+        } else {
+          this.logger.verbose(`[backend] ${text.trimEnd()}`);
+        }
+      }
+    } catch {}
+  }
+  #nextBackendBuildStatusGeneration(generation) {
+    if (typeof generation === "number") {
+      this.#backendBuildStatusGeneration = Math.max(this.#backendBuildStatusGeneration, generation);
+      return generation;
+    }
+    this.#backendBuildStatusGeneration += 1;
+    return this.#backendBuildStatusGeneration;
+  }
+  #recordBackendBuildStatus({
+    generation,
+    ok,
+    files,
+    message
+  }) {
+    const status = createBackendBuildStatus({
+      generation: this.#nextBackendBuildStatusGeneration(generation),
+      ok,
+      files,
+      message
+    });
+    this.#recordBuildStatus(status);
+    return status;
+  }
+  #recordBackendReadyStatus() {
+    const previous = this.#buildStatusByPhase.get("backend");
+    const startStatus = this.#backendStartStatus;
+    if (startStatus || previous?.ok === false) {
+      const status = this.#recordBackendBuildStatus({
+        generation: startStatus?.generation ?? previous?.generation,
+        ok: true,
+        files: startStatus?.files ?? previous?.files ?? [],
+        message: "Backend ready"
+      });
+      this.#sendOrQueueBuildStatus(status);
+    }
+    this.#backendStartStatus = null;
+  }
+  #setBackendLifecycleState(next, detail) {
+    if (this.#backendLifecycleState === next && !detail)
+      return;
+    const prev = this.#backendLifecycleState;
+    this.#backendLifecycleState = next;
+    this.logger.verbose(`[backend-lifecycle] ${prev} -> ${next}${detail ? ` ${detail}` : ""}`);
+  }
+  #sendToBackend(message) {
+    if (!this.#backend || !this.#backendReady) {
+      if (message.type === "css-updated" || message.type === "pages-updated" || message.type === "build-status") {
+        this.logger.verbose(`backend is not ready; will replay ${message.type}`);
+        return;
+      }
+      if (message.type !== "builder-ready")
+        this.logger.warn(`backend is not ready; dropping ${message.type}`);
+      return;
+    }
+    try {
+      this.#backend.send(message);
+    } catch (err) {
+      this.logger.warn(`failed to send ${message.type} to backend: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  async#stopBackend() {
+    if (!this.#backend)
+      return;
+    const backend = this.#backend;
+    this.#plannedBackendStops.add(backend);
+    this.#backendReady = false;
+    this.#setBackendLifecycleState("stopping", `pid=${backend.pid}`);
+    this.logger.verbose(`stopping backend pid=${backend.pid}`);
+    try {
+      backend.kill("SIGTERM");
+      const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), BACKEND_GRACEFUL_TIMEOUT_MS));
+      const result = await Promise.race([backend.exited, timeout]);
+      if (result === "timeout") {
+        this.logger.warn(`backend pid=${backend.pid} did not exit in ${BACKEND_GRACEFUL_TIMEOUT_MS}ms; force killing`);
+        backend.kill("SIGKILL");
+        await backend.exited.catch(() => {
+          return;
+        });
+      }
+    } finally {
+      if (this.#backend === backend)
+        this.#backend = null;
+      this.#setBackendLifecycleState("stopped", `pid=${backend.pid}`);
+    }
+  }
+  #scheduleBackendRestart(reason) {
+    this.#pendingRestartReason = mergeBackendRestartReasons(this.#pendingRestartReason, reason);
+    const pending = this.#pendingRestartReason;
+    this.#setBackendLifecycleState("restart-pending", `generation=${pending.generation ?? "(unknown)"} files=${pending.files.length} roles=${pending.roles.join(",") || "(none)"}`);
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
+    if (this.#restartTimer)
+      clearTimeout(this.#restartTimer);
+    this.#restartTimer = setTimeout(() => {
+      this.#restartTimer = null;
+      const next = this.#pendingRestartReason;
+      this.#pendingRestartReason = null;
+      if (next)
+        this.#restartBackend(next);
+    }, BACKEND_RESTART_DEBOUNCE_MS);
+  }
+  async#restartBackend(reason) {
+    this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
+    this.#backendRecoveryAttempts = 0;
+    await Promise.all([this.#stopBackend(), this.#backendGraph.refresh()]);
+    this.#startBackend({ generation: reason.generation, files: reason.files });
+  }
+  #scheduleBackendRecovery(reason) {
+    if (this.#backendRecoveryTimer || this.#backend)
+      return;
+    if (shouldAbandonBackendRecovery(this.#backendRecoveryAttempts)) {
+      const message = `Backend exited ${this.#backendRecoveryAttempts} times in a row (${reason}); waiting for an edit or a green build to retry.`;
+      this.#backendGaveUp = true;
+      this.#setBackendLifecycleState("stopped", `gave up after ${this.#backendRecoveryAttempts} recovery attempts`);
+      this.logger.error(`[backend-recovery] ${message}`);
+      if (this.#backendStderrTail.length > 0) {
+        this.logger.error(`[backend-recovery] recent backend stderr:
+${this.#backendStderrTail.join(`
+`)}`);
+      }
+      const abandonedStatus = this.#recordBackendBuildStatus({ ok: false, files: [], message });
+      this.#sendOrQueueBuildStatus(abandonedStatus);
+      return;
+    }
+    this.#setBackendLifecycleState("recovering", reason);
+    const attempt = this.#backendRecoveryAttempts;
+    const delay = Math.min(BACKEND_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BACKEND_RECOVERY_MAX_DELAY_MS);
+    this.#backendRecoveryAttempts = attempt + 1;
+    const failureStatus = this.#recordBackendBuildStatus({
+      ok: false,
+      files: [],
+      message: `Backend exited unexpectedly (${reason}); restarting in ${delay}ms`
+    });
+    this.#sendOrQueueBuildStatus(failureStatus);
+    this.logger.warn(`[backend-recovery] backend exited unexpectedly (${reason}); restarting in ${delay}ms (attempt ${this.#backendRecoveryAttempts})`);
+    if (this.#backendStderrTail.length > 0) {
+      this.logger.warn(`[backend-recovery] recent backend stderr:
+${this.#backendStderrTail.join(`
+`)}`);
+    }
+    this.#backendRecoveryTimer = setTimeout(() => {
+      this.#backendRecoveryTimer = null;
+      if (this.#backend)
+        return;
+      this.#backendGraph.refresh().finally(() => {
+        if (!this.#backend)
+          this.#startBackend({ generation: failureStatus.generation, files: failureStatus.files });
+      });
+    }, delay);
+  }
+  #enqueueBuilderMessage(message) {
+    this.#builderMessageQueue = this.#builderMessageQueue.then(() => this.#handleBuilderMessage(message)).catch((err) => {
+      this.logger.warn(`failed to handle builder message: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+  async#handleBuilderMessage(message) {
+    if (message.type === "build-status") {
+      this.#recordBuildStatus(message.data);
+      this.#sendOrQueueBuildStatus(message.data);
+      this.#reviveBackendAfterGreenBuild(message.data);
+      return;
+    }
+    if (message.type === "pages-updated")
+      this.#recordLastGood(message);
+    if (message.type === "css-updated")
+      this.#recordLastGood(message);
+    if (message.type === "invalidate") {
+      await this.#handleInvalidate(message);
+      return;
+    }
+    this.#sendToBackend(message);
+  }
+  async#handleInvalidate(message) {
+    this.#logDevPlan(message);
+    const wantsDevHostRestart = shouldRestartDevHostByDevPlan(message);
+    const pending = this.#pendingRecycle;
+    if (wantsDevHostRestart || shouldRestartBuilderByDevPlan(message) || pending && message.kinds.includes("code")) {
+      const refreshConfig = wantsDevHostRestart || (pending?.refreshConfig ?? false);
+      const merged = pending ? mergeInvalidateMessages(pending.message, message) : message;
+      const generation = message.devPlan?.generation ?? message.generation;
+      if (hasBuildFailureForGeneration(this.#buildStatusByPhase, generation)) {
+        this.#deferRecycle(merged, { refreshConfig, generation });
+        return;
+      }
+      this.#pendingRecycle = null;
+      try {
+        if (refreshConfig)
+          await this.#restartDevHost(merged);
+        else
+          await this.#restartDevChildren(merged);
+      } catch (err) {
+        this.#recordDevHostRestartFailure(merged, err, refreshConfig ? "Config" : "Runtime metadata");
+        this.#resurrectDevChildren(merged);
+      }
+      return;
+    }
+    if (await this.#shouldRestartBackend(message)) {
+      this.#scheduleBackendRestart(backendRestartReasonFromMessage(message));
+      return;
+    }
+    this.#sendToBackend(message);
+  }
+  #deferRecycle(message, { refreshConfig, generation }) {
+    this.#pendingRecycle = { message, refreshConfig };
+    const kind = refreshConfig ? "Config" : "Runtime metadata";
+    this.logger.warn(`[dev-host] ${kind.toLowerCase()} restart deferred generation=${generation ?? "(unknown)"}; keeping the running dev server until the build error is fixed`);
+    const status = {
+      generation: generation ?? this.#nextBackendBuildStatusGeneration(),
+      phase: "scan",
+      ok: false,
+      files: message.files,
+      message: `${kind} change is on hold while the build is failing; it will apply automatically once the error is fixed.`
+    };
+    this.#recordBuildStatus(status);
+    this.#sendOrQueueBuildStatus(status);
+  }
+  #resurrectDevChildren(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    if (!this.#backend)
+      this.#startBackend({ generation, files: message.files });
+    this.#scheduleBuilderRecovery({ generation, files: message.files });
+  }
+  #scheduleBuilderRecovery(reason) {
+    if (this.#builderRecoveryTimer || this.#builder)
+      return;
+    const attempt = this.#builderRecoveryAttempts;
+    const delay = Math.min(BUILDER_RECOVERY_BASE_DELAY_MS * 2 ** attempt, BUILDER_RECOVERY_MAX_DELAY_MS);
+    this.#builderRecoveryAttempts = attempt + 1;
+    this.logger.warn(`[builder-recovery] builder is down; retrying start in ${delay}ms (attempt ${this.#builderRecoveryAttempts})`);
+    this.#builderRecoveryTimer = setTimeout(() => {
+      this.#builderRecoveryTimer = null;
+      if (this.#builder)
+        return;
+      this.#recoverBuilder(reason);
+    }, delay);
+  }
+  async#recoverBuilder(reason) {
+    try {
+      await this.#startBuilder();
+    } catch (err) {
+      this.logger.warn(`[builder-recovery] builder start failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.#scheduleBuilderRecovery(reason);
+      return;
+    }
+    this.#builderRecoveryAttempts = 0;
+    this.logger.info("[builder-recovery] builder recovered");
+    const status = {
+      generation: reason.generation ?? this.#nextBackendBuildStatusGeneration(),
+      phase: "scan",
+      ok: true,
+      files: reason.files,
+      message: "Builder recovered"
+    };
+    this.#recordBuildStatus(status);
+    this.#sendOrQueueBuildStatus(status);
+    if (!this.#backend && !this.#backendRecoveryTimer) {
+      this.#startBackend({ generation: reason.generation, files: reason.files });
+    }
+  }
+  #reviveBackendAfterGreenBuild(status) {
+    if (!status.ok || !this.#backendGaveUp || this.#backend || this.#backendRecoveryTimer)
+      return;
+    this.logger.info(`[backend-recovery] build went green (generation=${status.generation}); retrying backend`);
+    this.#backendRecoveryAttempts = 0;
+    this.#startBackend({ generation: status.generation, files: status.files });
+  }
+  async#restartDevChildren(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    this.logger.warn(`[dev-host] recycling builder/backend for runtime metadata generation=${generation ?? "(unknown)"} files=${message.files.length}`);
+    await this.#recycleDevChildren(message);
+  }
+  async#restartDevHost(message) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    this.logger.warn(`[dev-host] config change detected; restarting dev host generation=${generation ?? "(unknown)"} files=${message.files.length}`);
+    await this.#recycleDevChildren(message, { refreshConfig: true });
+  }
+  async#recycleDevChildren(message, { refreshConfig = false } = {}) {
+    const generation = message.devPlan?.generation ?? message.generation;
+    if (this.#restartTimer) {
+      clearTimeout(this.#restartTimer);
+      this.#restartTimer = null;
+    }
+    if (this.#backendRecoveryTimer) {
+      clearTimeout(this.#backendRecoveryTimer);
+      this.#backendRecoveryTimer = null;
+    }
+    if (this.#builderRecoveryTimer) {
+      clearTimeout(this.#builderRecoveryTimer);
+      this.#builderRecoveryTimer = null;
+    }
+    this.#builderRecoveryAttempts = 0;
+    this.#pendingRestartReason = null;
+    this.#lastGoodFrontend = {};
+    this.#buildStatusByPhase.clear();
+    this.#pendingBuildStatusReplay = [];
+    await this.#stopBackend();
+    this.#stopBuilder();
+    if (refreshConfig) {
+      await this.app.getConfig({ refresh: true });
+      const { env } = await this.app.prepareCommand("start");
+      Object.assign(this.env, env);
+    }
+    await this.#backendGraph.refresh();
+    await this.#startBuilder();
+    this.#startBackend({ generation, files: message.files });
+  }
+  #recordLastGood(message) {
+    if (message.type === "pages-updated") {
+      if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.pages, message))
+        return;
+      this.#lastGoodFrontend.pages = message;
+      this.logger.verbose(`[last-good] pages generation=${message.data.generation ?? "(unknown)"} buildId=${message.data.buildId}`);
+      return;
+    }
+    if (!shouldReplaceLastGoodMessage(this.#lastGoodFrontend.css, message))
+      return;
+    this.#lastGoodFrontend.css = message;
+    this.logger.verbose(`[last-good] css generation=${message.data.generation ?? "(unknown)"} assets=${Object.keys(message.data.cssAssets).length}`);
+  }
+  #recordDevHostRestartFailure(message, err, kind) {
+    const generation = message.devPlan?.generation ?? message.generation ?? this.#nextBackendBuildStatusGeneration();
+    const detail = err instanceof Error ? err.message : String(err);
+    this.logger.warn(`[dev-host] ${kind.toLowerCase()} restart failed generation=${generation}: ${detail}`);
+    const status = {
+      generation,
+      phase: "scan",
+      ok: false,
+      files: message.files,
+      message: `${kind} change failed to apply; recovering the dev server automatically: ${detail}`
+    };
+    this.#recordBuildStatus(status);
+    this.#sendOrQueueBuildStatus(status);
+  }
+  #recordBuildStatus(status) {
+    const recovered = shouldMarkBuildPhaseRecovered(this.#buildStatusByPhase, status);
+    this.#buildStatusByPhase.set(status.phase, status);
+    const label = `[build-status] generation=${status.generation} phase=${status.phase} ok=${status.ok} files=${status.files.length}`;
+    if (status.ok)
+      this.logger.verbose(`${label}${recovered ? " recovered=1" : ""}`);
+    else
+      this.logger.warn(`${label}${status.message ? ` message=${status.message}` : ""}`);
+  }
+  #sendOrQueueBuildStatus(status) {
+    if (!this.#backend || shouldQueueBuildStatusReplay(this.#backendReady, this.#pendingBuildStatusReplay.length)) {
+      this.#pendingBuildStatusReplay.push(status);
+      this.logger.verbose(`backend is not ready; will replay build-status generation=${status.generation} phase=${status.phase}`);
+      return;
+    }
+    this.#sendToBackend({ type: "build-status", data: status });
+  }
+  #replayBuilderState() {
+    if (!this.#backendReady)
+      return;
+    if (this.#lastGoodFrontend.css)
+      this.#sendToBackend(this.#lastGoodFrontend.css);
+    if (this.#lastGoodFrontend.pages)
+      this.#sendToBackend(this.#lastGoodFrontend.pages);
+    const queuedStatuses = this.#pendingBuildStatusReplay.splice(0);
+    for (const status of buildStatusReplaySequence(queuedStatuses, this.#buildStatusByPhase)) {
+      this.#sendToBackend({ type: "build-status", data: status });
+    }
+  }
+  #logDevPlan(message) {
+    if (!message.devPlan)
+      return;
+    const { generation, roles, actions, reasonByFile } = message.devPlan;
+    this.logger.verbose(`[dev-plan] generation=${generation} roles=${roles.join(",") || "(none)"} actions=${actions.join(",") || "(none)"} reasons=${Object.keys(reasonByFile).length}`);
+  }
+  async#shouldRestartBackend(message) {
+    if (message.kinds.length === 1 && message.kinds[0] === "css")
+      return false;
+    if (message.devPlan) {
+      const shouldRestart = shouldRestartBackendByDevPlan(message) ?? false;
+      if (shouldRestart && message.kinds.includes("code"))
+        await this.#backendGraph.refresh();
+      return shouldRestart;
+    }
+    if (message.kinds.includes("code"))
+      await this.#backendGraph.refresh();
+    if (message.files.some((file) => this.#isBackendFile(file)))
+      return true;
+    if (!this.#backendGraph.lastRefreshSucceeded) {
+      const fallbackFiles = message.files.filter((file) => isLegacyBackendFallbackFile(file, this.app.workspace.workspaceRoot));
+      if (fallbackFiles.length > 0) {
+        this.logger.warn(`[backend-graph] using path-role fallback for legacy invalidate; restart files=${fallbackFiles.length}`);
+        return true;
+      }
+    }
+    return false;
+  }
+  #isBackendFile(file) {
+    return this.#backendGraph.has(file);
+  }
+  async#startBuilder() {
+    const startTime = Date.now();
+    this.app.verbose(`[cli] waiting for builder to complete initial base build\u2026`);
+    let lastError;
+    for (let attempt = 1;attempt <= BUILDER_START_MAX_ATTEMPTS; attempt++) {
+      this.#builder = await IncrementalBuilderHost.create(this.app, this.env, (msg) => {
+        this.#enqueueBuilderMessage(msg);
+      });
+      try {
+        await this.#waitForBuilderReady(attempt);
+        this.app.verbose(`[cli] base build ready in ${Date.now() - startTime}ms \u2014 starting backend`);
+        return this.#builder;
+      } catch (err) {
+        lastError = err;
+        this.#stopBuilder();
+        if (attempt >= BUILDER_START_MAX_ATTEMPTS)
+          break;
+        this.app.verbose(`[cli] builder failed before ready; retrying (${attempt + 1}/${BUILDER_START_MAX_ATTEMPTS})`);
+      }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+  }
+  #waitForBuilderReady(attempt) {
+    return new Promise((resolve, reject) => {
+      if (!this.#builder)
+        throw new Error("Builder Not Found");
+      let settled = false;
+      const settle = (fn) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timeout);
+        fn();
+      };
+      const timeout = setTimeout(() => {
+        settle(() => reject(new Error("[cli] builder timed out before emitting builder-ready")));
+      }, BUILDER_READY_TIMEOUT_MS);
+      this.#builder.start({
+        onExit: () => {
+          settle(() => reject(new Error(`[cli] builder exited before emitting builder-ready (attempt ${attempt})`)));
+        },
+        onReady: () => {
+          settle(resolve);
+        },
+        onRestartReady: () => {
+          this.logger.verbose("[builder-recovery] builder ready after restart; replaying latest state");
+          this.#replayBuilderState();
+        }
+      });
+    });
+  }
+  #sendToBuilder(message) {
+    if (message.type === "build-csr" && this.env.AKAN_DEV_CSR_REBUILD !== "1") {
+      Object.assign(this.env, { AKAN_DEV_CSR_REBUILD: "1" });
+      this.logger.verbose(`[csr] armed dev CSR rebuilds (${message.reason})`);
+    }
+    if (this.#builder?.send(message))
+      return;
+    const status = this.#builder?.status ?? "stopped";
+    if (message.type === "build-route") {
+      this.#sendToBackend({
+        type: "build-route-res",
+        id: message.id,
+        ok: false,
+        error: `builder is ${status}; reload after the builder is ready`
+      });
+      return;
+    }
+    if (message.type === "build-csr") {
+      this.#sendToBackend({
+        type: "build-csr-res",
+        id: message.id,
+        ok: false,
+        error: `builder is ${status}; reload after the builder is ready`
+      });
+      return;
+    }
+    this.logger.warn("akanAppHost builder is not running");
+  }
+  #stopBuilder() {
+    if (!this.#builder)
+      return;
+    this.#builder.stop();
+    this.#builder = null;
+  }
+}
+// pkgs/@akanjs/devkit/applicationTestPreload.ts
+import path3 from "path";
+var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
+async function resolveSignalTestPreloadPath(target) {
+  const candidates = [];
+  const addResolvedPackageCandidate = (basePath) => {
+    try {
+      candidates.push(path3.join(path3.dirname(Bun.resolveSync("akanjs/package.json", basePath)), SIGNAL_TEST_PRELOAD_PATH));
+    } catch {}
+  };
+  addResolvedPackageCandidate(target.cwdPath);
+  addResolvedPackageCandidate(process.cwd());
+  addResolvedPackageCandidate(path3.dirname(Bun.main));
+  addResolvedPackageCandidate(import.meta.dir);
+  candidates.push(path3.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(path3.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  const uniqueCandidates = [...new Set(candidates)];
+  for (const candidate of uniqueCandidates) {
+    if (await Bun.file(candidate).exists())
+      return candidate;
+  }
+  throw new Error(`Failed to locate ${SIGNAL_TEST_PRELOAD_PATH} from ${target.cwdPath}.
+Probed paths:
+${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
+`)}`);
+}
+
+// pkgs/@akanjs/cli/application/application.runner.ts
+import { Logger as Logger4 } from "akanjs/common";
+import ora from "ora";
+
+// pkgs/@akanjs/cli/openBrowser.ts
+import { spawn } from "child_process";
+function openBrowser(url) {
+  const command = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
+  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore" });
+  child.on("error", () => {});
+  child.unref();
+  return Promise.resolve();
+}
+
+// pkgs/@akanjs/cli/application/application.runner.ts
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-esa1kj7v.js")).ApplicationBuildRunner;
+var loadReleasePackager = async () => (await import("./applicationReleasePackager-brvth6rs.js")).ApplicationReleasePackager;
+var loadCapacitorApp = async () => (await import("./capacitorApp-y0h6cgft.js")).CapacitorApp;
+var loadPrompts = async () => await import("@inquirer/prompts");
+
+class ApplicationRunner extends runner("application") {
+  async createApplication(appName, workspace, libs = []) {
+    await workspace.applyTemplate({
+      basePath: `apps/${appName}`,
+      template: "app",
+      dict: { appName },
+      options: { libs }
+    });
+    return AppExecutor.from(workspace, appName);
+  }
+  async removeApplication(app) {
+    await app.workspace.exec(`rm -rf apps/${app.name}`);
+  }
+  async getConfig(app) {
+    return await app.getConfig();
+  }
+  async getScriptFilename(app) {
+    if (!await app.exists("script")) {
+      await app.mkdir("script");
+      throw new Error(`No script files found. make a script file in apps/${app.name}/script folder`);
+    }
+    const scriptFiles = (await app.readdir("script")).filter((file) => file.endsWith(".ts"));
+    const scriptFile = await (await loadPrompts()).select({
+      message: "Select script to run",
+      choices: scriptFiles.map((file) => ({ name: file, value: file.replace(".ts", "") }))
+    });
+    return scriptFile;
+  }
+  async runScript(app, filename) {
+    const scriptName = filename.endsWith(".ts") ? filename.slice(0, -3) : filename;
+    if (scriptName.includes("/") || scriptName.includes("\\") || scriptName.includes("..")) {
+      throw new Error(`Invalid script filename: ${filename}`);
+    }
+    const scriptPath = `script/${scriptName}.ts`;
+    if (!await app.exists(scriptPath))
+      throw new Error(`Script file not found: apps/${app.name}/${scriptPath}`);
+    await app.spawn("bun", [scriptPath], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script" }),
+      stdio: "inherit"
+    });
+  }
+  async runConsole(app) {
+    const serverPath = `${app.cwdPath}/server.ts`;
+    if (!await app.exists("server.ts"))
+      throw new Error(`Server file not found: apps/${app.name}/server.ts`);
+    const code = `
+const serverModule = await import(${JSON.stringify(serverPath)});
+const { assertAkanConsoleAllowed, startAkanConsole } = await import("akanjs/server");
+const server = serverModule.server;
+if (!server?.start) throw new Error("server.ts must export server with start()");
+assertAkanConsoleAllowed(server.env);
+await server.start({ listen: false, web: false });
+try {
+  await startAkanConsole(server, {
+    globals: {
+      srv: serverModule.srv,
+      sig: serverModule.sig,
+      db: serverModule.db,
+      cnst: serverModule.cnst,
+      dict: serverModule.dict,
+      option: serverModule.option,
+    },
+  });
+} finally {
+  await server.stop();
+}
+`;
+    await app.spawn("bun", ["-e", code], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console" }),
+      stdio: "inherit"
+    });
+  }
+  async typecheck(app, options = {}) {
+    await new (await loadBuildRunner())(app).typecheck(options);
+  }
+  async test(exec) {
+    const isSignalTarget = exec instanceof AppExecutor || exec instanceof LibExecutor;
+    const preloadPath = isSignalTarget ? await resolveSignalTestPreloadPath(exec) : null;
+    const env = isSignalTarget ? {
+      AKAN_TEST_SIGNAL: "1",
+      AKAN_TEST_TARGET_TYPE: exec.type,
+      AKAN_TEST_TARGET_NAME: exec.name,
+      AKAN_TEST_LIBS: exec.getScanInfo({ allowEmpty: true })?.getLibs().join(",") ?? ""
+    } : {};
+    const args = preloadPath ? ["test", "--isolate", "--preload", preloadPath] : ["test", "--isolate"];
+    await exec.spawn("bun", args, {
+      ...isSignalTarget ? { env: { ...process.env, ...env } } : {},
+      stdio: "inherit"
+    });
+  }
+  async build(app, {
+    fast = false,
+    reporter,
+    spinner = false
+  } = {}) {
+    return new (await loadBuildRunner())(app, { fast, reporter }).build({ spinner });
+  }
+  async start(app, { open = false, onStart, withInk = false } = {}) {
+    const { env } = await app.prepareCommand("start");
+    const appHost = await new AkanAppHost(app, { env, withInk }).start();
+    onStart?.();
+    if (open)
+      setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
+    return appHost;
+  }
+  async buildIos(app, { target, env = "debug", regenerate = false } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      await new (await loadCapacitorApp())(app, mobileTarget.config).buildIos({ env, regenerate });
+    });
+  }
+  async startIos(app, {
+    open = false,
+    operation = "local",
+    env = "local",
+    target,
+    device,
+    regenerate = false,
+    noAllowProvisioningUpdates = false
+  } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    if (operation === "release")
+      await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      const capacitorApp = new (await loadCapacitorApp())(app, mobileTarget.config);
+      await capacitorApp.runIos({ operation, env, regenerate, noAllowProvisioningUpdates, iosDeviceId: device });
+      if (open)
+        await capacitorApp.openIos();
+    });
+  }
+  async releaseIos(app, { target, env = "main", regenerate = false } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    for (const mobileTarget of targets) {
+      await new (await loadCapacitorApp())(app, mobileTarget.config).buildIos({ env, regenerate });
+    }
+  }
+  async buildAndroid(app, { target, env = "debug", regenerate = false } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      await new (await loadCapacitorApp())(app, mobileTarget.config).buildAndroid("apk", { env, regenerate });
+    });
+  }
+  async startAndroid(app, {
+    open = false,
+    operation = "local",
+    env = "local",
+    target,
+    regenerate = false
+  } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    if (operation === "release")
+      await this.#buildMobileCsr(app, env);
+    await this.#runMobileTargets(targets, async (mobileTarget) => {
+      const capacitorApp = new (await loadCapacitorApp())(app, mobileTarget.config);
+      await capacitorApp.runAndroid({ operation, env, regenerate });
+      if (open)
+        await capacitorApp.openAndroid();
+    });
+  }
+  async releaseAndroid(app, assembleType, { target, env = "main", regenerate = false } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    await this.#buildMobileCsr(app, env);
+    for (const mobileTarget of targets) {
+      await new (await loadCapacitorApp())(app, mobileTarget.config).buildAndroid(assembleType, { env, regenerate });
+      app.log(`Release Android ${app.name}/${mobileTarget.name} ${assembleType} Completed.`);
+      app.log(`Path : ${app.cwdPath}/android/app/build/outputs/${assembleType === "apk" ? "apk" : "bundle"}/release`);
+    }
+  }
+  async#buildMobileCsr(app, env) {
+    const prevEnv = {
+      AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
+      AKAN_PUBLIC_OPERATION_MODE: process.env.AKAN_PUBLIC_OPERATION_MODE,
+      APP_OPERATION_MODE: process.env.APP_OPERATION_MODE
+    };
+    Object.assign(process.env, {
+      AKAN_PUBLIC_ENV: env,
+      AKAN_PUBLIC_OPERATION_MODE: env === "local" ? "local" : "cloud",
+      APP_OPERATION_MODE: "release"
+    });
+    try {
+      await new (await loadBuildRunner())(app).build({ spinner: true });
+    } finally {
+      for (const [key, value] of Object.entries(prevEnv)) {
+        if (value === undefined)
+          delete process.env[key];
+        else
+          process.env[key] = value;
+      }
+    }
+  }
+  async#runMobileTargets(targets, task) {
+    const results = [];
+    for (const target of targets) {
+      try {
+        await task(target);
+        results.push({ target: target.name });
+      } catch (error) {
+        results.push({ target: target.name, error });
+      }
+    }
+    const failures = results.filter((result) => result.error);
+    if (failures.length === 0)
+      return;
+    for (const failure of failures) {
+      const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+      Logger4.rawLog(`Mobile target ${failure.target} failed: ${message}`, undefined, "error");
+    }
+    throw new Error(`${failures.length}/${results.length} mobile targets failed`);
+  }
+  async codepush(app, os) {
+    const [target] = await resolveMobileTargets(app, undefined);
+    if (!target)
+      throw new Error(`No mobile target configured for ${app.name}`);
+    const capacitorApp = new (await loadCapacitorApp())(app, target.config);
+    await capacitorApp.init();
+  }
+  #getLocalDatabaseServices(mode) {
+    if (mode === "single")
+      return [];
+    if (mode === "multiple")
+      return ["redis", "libsql"];
+    return ["redis", "postgres"];
+  }
+  async#isLocalDatabaseUp(workspace, mode) {
+    const requiredServices = this.#getLocalDatabaseServices(mode);
+    if (!requiredServices.length)
+      return true;
+    const output = await workspace.spawn("docker", ["compose", "ps", "--services", "--status", "running"], {
+      cwd: `${workspace.workspaceRoot}/local`
+    });
+    const runningServices = new Set(output.split(/\s+/).filter(Boolean));
+    return requiredServices.every((service) => runningServices.has(service));
+  }
+  async dbup(workspace, mode = "multiple") {
+    if (mode === "single")
+      return true;
+    try {
+      await workspace.applyTemplate({
+        basePath: "local",
+        template: "localDev",
+        dict: { repoName: workspace.repoName },
+        overwrite: false
+      });
+      const wasAlreadyUp = await this.#isLocalDatabaseUp(workspace, mode);
+      if (!wasAlreadyUp)
+        await workspace.spawn(`docker`, ["compose", "up", "-d", ...this.#getLocalDatabaseServices(mode)], {
+          cwd: `${workspace.workspaceRoot}/local`
+        });
+      return wasAlreadyUp;
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error) || "Unknown error";
+      throw new Error([
+        "Docker daemon may not be running. Please install Docker or start the Docker daemon and try again.",
+        `Original error:
+${detail}`
+      ].join(`
+
+`));
+    }
+  }
+  async dbdown(workspace) {
+    await workspace.spawn(`docker`, ["compose", "down"], { cwd: `${workspace.workspaceRoot}/local` });
+  }
+  async configureApp(app) {
+    const [target] = await resolveMobileTargets(app, undefined);
+    if (!target)
+      throw new Error(`No mobile target configured for ${app.name}`);
+    const capacitorApp = new (await loadCapacitorApp())(app, target.config);
+    await capacitorApp.init();
+    if (await (await loadPrompts()).confirm({ message: "want to add camera permission?" }))
+      await capacitorApp.addCamera();
+    if (await (await loadPrompts()).confirm({ message: "want to add contact permission?" }))
+      await capacitorApp.addContact();
+    if (await (await loadPrompts()).confirm({ message: "want to add location permission?" }))
+      await capacitorApp.addLocation();
+    await capacitorApp.save();
+  }
+  async releaseSource(app, { rebuild, buildNum = 0, environment = "debug", local = true } = {}) {
+    await new (await loadReleasePackager())(app, { build: () => this.build(app).then(() => {
+      return;
+    }) }).releaseSource({
+      rebuild,
+      buildNum,
+      environment,
+      local
+    });
+    return;
+  }
+  async createApplicationTemplate(workspace, appName) {
+    await workspace.applyTemplate({ basePath: `apps/${appName}`, template: "appRoot", dict: { appName } });
+  }
+  async compressProjectFiles(app, { rebuild, buildNum = 0, environment = "debug", local = true } = {}) {
+    await new (await loadReleasePackager())(app, {
+      build: () => this.build(app).then(() => {
+        return;
+      })
+    }).compressProjectFiles({
+      rebuild,
+      buildNum,
+      environment,
+      local
+    });
+    return;
+  }
+  async generateApplicationTemplate(app) {
+    const openAIApiKey = process.env.OPENAI_API_KEY;
+    if (!openAIApiKey)
+      throw new Error("OPENAI_API_KEY is not set");
+    const [{ StringOutputParser }, { PromptTemplate }, { RunnableSequence }, { ChatOpenAI }, prompts] = await Promise.all([
+      import("@langchain/core/output_parsers"),
+      import("@langchain/core/prompts"),
+      import("@langchain/core/runnables"),
+      import("@langchain/openai"),
+      loadPrompts()
+    ]);
+    const chatModel = new ChatOpenAI({ modelName: "gpt-4o", openAIApiKey });
+    const projectName = await prompts.input({ message: "please enter project name." });
+    const projectDesc = await prompts.input({
+      message: "please enter project description. (40 ~ 60 characters)"
+    });
+    const spinner = ora("Gerating project files...");
+    const mainPrompt = PromptTemplate.fromTemplate(`prompt.requestApplication()`);
+    const chain = RunnableSequence.from([mainPrompt, chatModel, new StringOutputParser]);
+    await chain.invoke({ projectName, projectDesc });
+    spinner.succeed("Loading complete!");
+    //! add path in tsconfig.json
+  }
+  async testApplication(app) {}
+}
+
+// pkgs/@akanjs/cli/application/application.script.ts
+class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
+  async confirmDatabaseModeDependencyInstall(databaseMode, installSpecs) {
+    return await confirm({
+      message: [
+        `Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}.`,
+        "Install them now?"
+      ].join(" "),
+      default: true
+    });
+  }
+  async syncDatabaseModeDependencies(app, akanConfig, databaseMode) {
+    const installSpecs = akanConfig.getMissingDatabaseModeDependencySpecs(databaseMode);
+    if (installSpecs.length === 0)
+      return;
+    const shouldInstall = await this.confirmDatabaseModeDependencyInstall(databaseMode, installSpecs);
+    if (!shouldInstall)
+      throw new Error(`Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}.`);
+    const spinner = app.workspace.spinning(`Installing database dependencies for ${databaseMode} mode...`);
+    try {
+      await app.workspace.spawn("bun", ["add", ...installSpecs], {
+        stdio: "inherit"
+      });
+      await app.workspace.getPackageJson({ refresh: true });
+      spinner.succeed(`Installed database dependencies for ${databaseMode} mode`);
+    } catch (error) {
+      spinner.fail(`Failed to install database dependencies for ${databaseMode} mode`);
+      throw error;
+    }
+  }
+  async confirmMobileDependencyInstall(installSpecs) {
+    return await confirm({
+      message: [`Mobile builds require missing dependencies: ${installSpecs.join(", ")}.`, "Install them now?"].join(" "),
+      default: true
+    });
+  }
+  async syncMobileDependencies(app, akanConfig) {
+    const installSpecs = akanConfig.getMissingMobileDependencySpecs();
+    if (installSpecs.length === 0)
+      return;
+    const shouldInstall = await this.confirmMobileDependencyInstall(installSpecs);
+    if (!shouldInstall)
+      throw new Error(`Mobile builds require missing dependencies: ${installSpecs.join(", ")}.`);
+    const spinner = app.workspace.spinning("Installing mobile dependencies...");
+    try {
+      await app.workspace.spawn("bun", ["add", ...installSpecs], {
+        stdio: "inherit"
+      });
+      await app.workspace.getPackageJson({ refresh: true });
+      spinner.succeed("Installed mobile dependencies");
+    } catch (error) {
+      spinner.fail("Failed to install mobile dependencies");
+      throw error;
+    }
+  }
+  async syncMobileAppCapacitorPlugins(app, akanConfig) {
+    const plugins = akanConfig.getMobileAppCapacitorPlugins();
+    if (plugins.length === 0)
+      return;
+    const packageJson = await app.getPackageJson({ refresh: true });
+    const dependencies = packageJson.dependencies ?? {};
+    const missing = plugins.filter((plugin) => !dependencies[plugin]);
+    if (missing.length === 0)
+      return;
+    const spinner = app.workspace.spinning(`Adding default Capacitor plugins to ${app.name}...`);
+    try {
+      packageJson.dependencies = { ...dependencies, ...Object.fromEntries(missing.map((plugin) => [plugin, "*"])) };
+      await app.setPackageJson(packageJson);
+      await app.workspace.spawn("bun", ["install"], { stdio: "inherit" });
+      await app.getPackageJson({ refresh: true });
+      spinner.succeed(`Added default Capacitor plugins to ${app.name}: ${missing.join(", ")}`);
+    } catch (error) {
+      spinner.fail(`Failed to add default Capacitor plugins to ${app.name}`);
+      throw error;
+    }
+  }
+  async createApplication(appName, workspace, { start = false, libs = [] } = {}) {
+    const spinner = workspace.spinning("Creating application...");
+    const app = await this.applicationRunner.createApplication(appName, workspace, libs);
+    spinner.succeed(`Application created in apps/${app.name}`);
+    await app.scanSync();
+    if (start)
+      await this.start(app, { open: true });
+  }
+  async removeApplication(app) {
+    const spinner = app.spinning("Removing application...");
+    await this.applicationRunner.removeApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) removed`);
+  }
+  async sync(sys) {
+    if (sys.type === "app")
+      await sys.scanSync();
+    else
+      await this.libraryScript.syncLibrary(sys);
+  }
+  async script(app, filename) {
+    const scriptFilename = filename ?? await this.applicationRunner.getScriptFilename(app);
+    await app.scanSync();
+    await this.applicationRunner.runScript(app, scriptFilename);
+  }
+  async console(app) {
+    await app.scanSync();
+    await this.applicationRunner.runConsole(app);
+  }
+  async build(app, { write = true, fast = false, quiet = false } = {}) {
+    await app.scanSync({ write });
+    if (!quiet)
+      Logger5.rawLog(`Creating an optimized production build for ${app.name}...`);
+    try {
+      const result = await this.applicationRunner.build(app, {
+        fast,
+        spinner: !quiet
+      });
+      Logger5.rawLog(`${app.name} built in dist/apps/${app.name}`);
+      if (!quiet)
+        ApplicationBuildReporter.printSummary(result);
+    } catch (error) {
+      Logger5.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
+      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      throw error;
+    }
+  }
+  async typecheck(app, { write = true, clean = false, incremental = true } = {}) {
+    await app.scanSync({ write });
+    const spinner = app.spinning(`Typechecking ${app.name}...`);
+    try {
+      await this.applicationRunner.typecheck(app, { clean, incremental });
+      spinner.succeed(`${app.name} typechecked`);
+    } catch (error) {
+      spinner.fail(`${app.name} typecheck failed`);
+      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      throw error;
+    }
+  }
+  async test(exec, { write = true } = {}) {
+    if (exec instanceof LibExecutor) {
+      await this.libraryScript.syncLibrary(exec);
+      const spinner2 = exec.spinning(`Preparing ${exec.name}...`);
+      spinner2.succeed(`${exec.name} prepared`);
+      await this.applicationRunner.test(exec);
+      return;
+    }
+    const spinner = exec.spinning(`Preparing ${exec.name}...`);
+    try {
+      if (exec instanceof PkgExecutor)
+        await exec.scan({ refresh: true });
+      else
+        await exec.scanSync({ write });
+      spinner.succeed(`${exec.name} prepared`);
+    } catch (error) {
+      spinner.fail(`${exec.name} prepare failed`);
+      throw error;
+    }
+    await this.applicationRunner.test(exec);
+  }
+  async start(app, {
+    open = false,
+    dbup = true,
+    withInk = false,
+    write = true
+  } = {}) {
+    await app.scanSync({ write });
+    const akanConfig = await app.getConfig();
+    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+    await this.syncDatabaseModeDependencies(app, akanConfig, databaseMode);
+    if (app.getEnv() === "local" && dbup && databaseMode !== "single") {
+      const wasDbAlreadyUp = await this.dbup(app.workspace, databaseMode);
+      if (!wasDbAlreadyUp)
+        process.on("SIGINT", async () => {
+          await this.dbdown(app.workspace);
+          process.exit(0);
+        });
+    }
+    const spinner = app.spinning("Preparing backend...");
+    const akanAppHost = await this.applicationRunner.start(app, {
+      open,
+      onStart: () => {
+        spinner.succeed(`${app.name} prepared, ready to start`);
+      },
+      withInk
+    });
+    return akanAppHost;
+  }
+  async buildIos(app, { write = true, target, env = "debug", regenerate = false } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildIos(app, { target, env, regenerate });
+  }
+  async startIos(app, {
+    open = false,
+    operation = "local",
+    env = "local",
+    write = true,
+    target,
+    device,
+    regenerate = false,
+    noAllowProvisioningUpdates = false
+  } = {}) {
+    await app.scanSync({ write });
+    const akanConfig = await app.getConfig();
+    await this.syncMobileDependencies(app, akanConfig);
+    await this.syncMobileAppCapacitorPlugins(app, akanConfig);
+    await this.applicationRunner.startIos(app, {
+      open,
+      operation,
+      env,
+      target,
+      device,
+      regenerate,
+      noAllowProvisioningUpdates
+    });
+  }
+  async releaseIos(app, { write = true, target, env = "main", regenerate = false, allowLocalRelease = false } = {}) {
+    await app.scanSync({ write });
+    if (env === "local" && !allowLocalRelease)
+      throw new Error("releaseIos --env local is blocked. Pass allowLocalRelease only for explicit local release testing.");
+    await this.applicationRunner.releaseIos(app, { target, env, regenerate });
+  }
+  async buildAndroid(app, { write = true, target, env = "debug", regenerate = false } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildAndroid(app, { target, env, regenerate });
+  }
+  async startAndroid(app, {
+    open = false,
+    operation = "local",
+    env = "local",
+    write = true,
+    target,
+    regenerate = false
+  } = {}) {
+    await app.scanSync({ write });
+    const akanConfig = await app.getConfig();
+    await this.syncMobileDependencies(app, akanConfig);
+    await this.syncMobileAppCapacitorPlugins(app, akanConfig);
+    await this.applicationRunner.startAndroid(app, {
+      open,
+      operation,
+      env,
+      target,
+      regenerate
+    });
+  }
+  async releaseAndroid(app, assembleType, { write = true, target, env = "main", regenerate = false, allowLocalRelease = false } = {}) {
+    await app.scanSync({ write });
+    if (env === "local" && !allowLocalRelease)
+      throw new Error("releaseAndroid --env local is blocked. Pass allowLocalRelease only for explicit local release testing.");
+    await this.applicationRunner.releaseAndroid(app, assembleType, {
+      target,
+      env,
+      regenerate
+    });
+  }
+  async configureApp(app) {
+    await this.applicationRunner.configureApp(app);
+  }
+  async releaseSource(app, options) {
+    await this.applicationRunner.releaseSource(app, options);
+  }
+  async codepush(app, os) {
+    await this.applicationRunner.codepush(app, os);
+  }
+  async dbup(workspace, mode = "multiple") {
+    const spinner = workspace.spinning(`Starting local database (${mode})...`);
+    const wasAlreadyUp = await this.applicationRunner.dbup(workspace, mode);
+    spinner.succeed(wasAlreadyUp ? `Local database (${mode}) was already up` : `Local database (${mode}) is up`);
+    return wasAlreadyUp;
+  }
+  async dbdown(workspace) {
+    const spinner = workspace.spinning("Stopping local database...");
+    await this.applicationRunner.dbdown(workspace);
+    spinner.succeed("Local database (/local/docker-compose.yaml) is down");
+  }
+  async testSys(sys) {
+    if (sys.type === "app")
+      await this.testApplication(sys);
+    else
+      await this.libraryScript.testLibrary(sys);
+  }
+  async testApplication(app) {
+    const spinner = app.spinning("Testing application...");
+    await this.applicationRunner.testApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) test is successful`);
+  }
+}
+
+export { openBrowser, ApplicationScript };