@akanjs/cli 3.0.0-beta.8 → 3.0.0

package/{index-sj5vxr8f.js → index-p993efkq.js}

@@ -1,178 +1,80 @@
 // @bun
+import {
+  ApplicationBuildReporter,
+  BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS,
+  SOURCE_EXTS,
+  shouldRestartBackendByDevPlan,
+  shouldRestartBuilderByDevPlan,
+  shouldAbandonBackendRecovery,
+  normalizeBackendReportedGeneration,
+  shouldRestartDevHostByDevPlan,
+  devHostStateOf,
+  isLegacyBackendFallbackFile,
+  shouldMarkBuildPhaseRecovered,
+  shouldKeepBuildFailure,
+  createBackendBuildStatus,
+  backendRestartReasonFromMessage,
+  mergeBackendRestartReasons,
+  shouldReplaceLastGoodMessage,
+  shouldQueueBuildStatusReplay,
+  hasBuildFailureForGeneration,
+  decideBuilderRssRecycle,
+  decideBuilderRssSettle,
+  decideIdleSuspend,
+  resolveIdleSuspendMs,
+  hasAnyBuildFailure,
+  shouldRefreshConfigOnIdleWake,
+  shouldHoldForReturningBuilder,
+  shouldWarnBuilderRssCeilingTight,
+  isRssCeilingUnreachable,
+  shouldRelayRecycledFrontendState,
+  mergeInvalidateMessages,
+  buildStatusReplaySequence,
+  filesChangedSince,
+  HmrWatcher,
+  WatchRootResolver
+} from "./index-48k96p55.js";
 import {
   runner,
   script
-} from "./index-0g7r8xz3.js";
+} from "./index-vpj42xwt.js";
 import {
   WorkspaceExecutor,
   AppExecutor,
   LibExecutor,
   PkgExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-3w94e7n3.js";
+import {
+  DesktopServerStage,
+  resolveMobileTargets,
+  resolveAppId,
+  NativeApp
+} from "./index-gbggbqcp.js";
 import {
   LibraryScript
-} from "./index-vxtad5bd.js";
+} from "./index-mgxpx3f2.js";
 import {
-  HmrWatcher,
-  WatchRootResolver
-} from "./index-hwkygn9s.js";
+  stripAnsi
+} from "./index-7md2g9vw.js";
 import {
   SlicePlanner,
   formatSlicePlan
-} from "./index-j9yhg404.js";
+} from "./index-jmrn54tt.js";
 import {
-  resolveMobileTargets
-} from "./index-47pj3aee.js";
-
-// 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/devLogBuffer.ts
-var ansi = new RegExp(`${String.fromCharCode(27)}(?:[@-Z\\\\-_]|\\[[\\s\\S]*?[@-~])`, "g");
-var stripAnsi = (text) => text.replace(ansi, "");
-var plainTextOf = (lines, { withApp = false } = {}) => {
-  const width = withApp ? lines.reduce((max, line) => Math.max(max, line.app.length), 0) : 0;
-  return lines.map((line) => `${withApp ? `${line.app.padEnd(width)} \u2502 ` : ""}${stripAnsi(line.text)}`).join(`
-`);
-};
-var HOST_SOURCE = "host";
-var childPrefix = /^\[child:(\d+) ([a-z-]+)\] \[(?:stdout|stderr)\] /;
-var sourceOf = (text) => {
-  const match = childPrefix.exec(text);
-  return match ? `#${match[1]} ${match[2]}` : HOST_SOURCE;
-};
-
-class DevLogBuffer {
-  static defaultLimit = 5000;
-  #limit;
-  #lines = [];
-  #partial = new Map;
-  #sources = new Map;
-  #seq = 0;
-  constructor({ limit = DevLogBuffer.defaultLimit } = {}) {
-    this.#limit = Math.max(1, limit);
-  }
-  get size() {
-    return this.#lines.length;
-  }
-  sourcesOf(app) {
-    return [...this.#sources.get(app) ?? []];
-  }
-  push(app, kind, chunk) {
-    const key = `${app}:${kind}`;
-    const parts = `${this.#partial.get(key) ?? ""}${chunk}`.split(`
-`);
-    this.#partial.set(key, parts.pop() ?? "");
-    return this.#append(app, kind, parts);
-  }
-  flushPartials() {
-    const flushed = [];
-    for (const [key, remainder] of [...this.#partial]) {
-      this.#partial.set(key, "");
-      if (!remainder)
-        continue;
-      const split = key.lastIndexOf(":");
-      const app = key.slice(0, split);
-      const kind = key.slice(split + 1) === "stderr" ? "stderr" : "stdout";
-      flushed.push(...this.#append(app, kind, [remainder]));
-    }
-    return flushed;
-  }
-  select({ app = null, source = null, grep, errorsOnly = false } = {}) {
-    const needle = grep?.trim().toLowerCase();
-    return this.#lines.filter((line) => {
-      if (app !== null && line.app !== app)
-        return false;
-      if (source !== null && line.source !== source)
-        return false;
-      if (errorsOnly && line.kind !== "stderr")
-        return false;
-      if (needle && !stripAnsi(line.text).toLowerCase().includes(needle))
-        return false;
-      return true;
-    });
-  }
-  clear(app = null) {
-    const kept = app === null ? [] : this.#lines.filter((line) => line.app !== app);
-    this.#lines.length = 0;
-    this.#lines.push(...kept);
-  }
-  #append(app, kind, texts) {
-    const known = this.#sources.get(app) ?? new Set;
-    this.#sources.set(app, known);
-    const added = texts.map((text) => {
-      const source = sourceOf(text);
-      known.add(source);
-      return { seq: ++this.#seq, app, source, kind, text };
-    });
-    this.#lines.push(...added);
-    if (this.#lines.length > this.#limit)
-      this.#lines.splice(0, this.#lines.length - this.#limit);
-    return added;
-  }
-}
-
-// 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)})`;
-  }
-}
+  openBrowser
+} from "./index-9dp031by.js";
 
 // pkgs/@akanjs/cli/application/application.script.ts
 import { confirm } from "@inquirer/prompts";
 import { Logger as Logger6 } from "akanjs/common";
 
 // pkgs/@akanjs/cli/application/application.runner.ts
+import { realpathSync } from "fs";
 import path5 from "path";
 
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
-import { Logger as Logger3 } from "akanjs/common";
+import path3 from "path";
+import { Logger as Logger2 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/sshTunnel.ts
 import { Client } from "ssh2";
@@ -261,7 +163,7 @@ var createSshTunnel = async (options) => {
       for (const socket of sockets)
         closeSocket(socket, error);
       closeQuietly(() => client.end());
-      closeBunServer(server);
+      server.stop();
     };
     client.once("error", (error) => closeTunnel(error));
     client.once("close", () => closeTunnel());
@@ -281,22 +183,10 @@ var closeBunSocket = (socket, error) => {
     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);
+  const { serveDomain, repoName } = WorkspaceExecutor.getBaseDevEnv();
   await createSshTunnel({
     localHost: "0.0.0.0",
     localPort: port,
@@ -304,13 +194,20 @@ var createTunnel = async (service, { app, environment, port = service === "postg
     srcPort: port,
     dstHost: `${service}-0.${service}-svc.${app.name}-${environment}.svc.cluster.local`,
     dstPort: service === "postgres" ? 5432 : 6379,
-    sshOptions
+    sshOptions: {
+      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
+    }
   });
   return `localhost:${port}`;
 };
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.host.ts
+import fs from "fs";
 import path from "path";
-import { Logger as Logger2 } from "akanjs/common";
+import { Logger } from "akanjs/common";
+import { CSR_DEV_DIRNAME, CSR_DEV_PATCHING_MARKER, SSR_DEV_DIRNAME } from "akanjs/server/hmr/csrDevManifest";
 import { MemoryLimit } from "akanjs/server/memoryLimit";
 var builderMsgTypeSet = new Set([
   "build-route-res",
@@ -319,16 +216,19 @@ var builderMsgTypeSet = new Set([
   "invalidate",
   "css-updated",
   "pages-updated",
+  "csr-updated",
+  "ssr-updated",
   "build-status",
-  "builder-metrics"
+  "builder-metrics",
+  "boot-armed"
 ]);
 
 class IncrementalBuilderHost {
   static #restartBaseDelayMs = 1000;
   static #restartMaxDelayMs = 30000;
   static #recycleDrainTimeoutMs = 30000;
-  static #devMaxRssBytes = 1200 * 1024 * 1024;
-  logger = new Logger2("IncrementalBuilderHost");
+  static #devMaxRssBytes = 2048 * 1024 * 1024;
+  logger = new Logger("IncrementalBuilderHost");
   entry;
   env;
   app;
@@ -343,20 +243,33 @@ class IncrementalBuilderHost {
   #recycleTimer = null;
   #recycleRequested = false;
   #spawnAfterRecycle = false;
+  #patcherOff = false;
   #manualStop = false;
   #inFlight = new Map;
   #startOptions = {};
-  constructor({ app, entry, env, stdio = "inherit", onMessage, onOutput }) {
+  constructor({
+    app,
+    entry,
+    env,
+    stdio = "inherit",
+    onMessage,
+    onOutput,
+    patcherOff = false
+  }) {
     this.app = app;
     this.entry = entry;
     this.env = env;
     this.#stdio = stdio;
     this.#onMessage = onMessage;
     this.#onOutput = onOutput ?? null;
+    this.#patcherOff = patcherOff;
   }
   get status() {
     return this.#status;
   }
+  get patcherOff() {
+    return this.#patcherOff;
+  }
   get pid() {
     return this.#proc?.pid ?? null;
   }
@@ -374,10 +287,16 @@ class IncrementalBuilderHost {
     this.ready = false;
     const afterRecycle = this.#spawnAfterRecycle;
     this.#spawnAfterRecycle = false;
+    this.#checkPatchingMarker(isRestart && !afterRecycle);
     let proc;
     proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
-      env: { ...this.env, AKAN_WATCH: "1", ...afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {} },
+      env: {
+        ...this.env,
+        AKAN_WATCH: "1",
+        ...afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {},
+        ...this.#patcherOff ? { AKAN_DEV_CSR_PATCHER: "off" } : {}
+      },
       stdio: ["ignore", this.#stdio, this.#stdio],
       ipc: (msg) => {
         if (this.#proc !== proc)
@@ -432,6 +351,17 @@ class IncrementalBuilderHost {
     }
     this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
   }
+  #checkPatchingMarker(afterCrash) {
+    const markers = [CSR_DEV_DIRNAME, SSR_DEV_DIRNAME].map((dirName) => path.join(this.app.cwdPath, ".akan/artifact", dirName, CSR_DEV_PATCHING_MARKER)).filter((marker) => fs.existsSync(marker));
+    if (markers.length === 0)
+      return;
+    if (afterCrash && !this.#patcherOff) {
+      this.#patcherOff = true;
+      this.logger.warn("the builder died while patching a dev module registry; registry saves go to a build worker until the next config or metadata restart (AKAN_DEV_CSR_PATCHER=off)");
+    }
+    for (const marker of markers)
+      fs.rmSync(marker, { force: true });
+  }
   async#drain(stream, kind) {
     if (!stream)
       return;
@@ -518,12 +448,8 @@ class IncrementalBuilderHost {
     const lost = [...this.#inFlight];
     this.#inFlight.clear();
     this.logger.warn(`failing ${lost.length} unanswered builder request(s): ${reason}`);
-    for (const [id, type] of lost) {
-      if (type === "build-route")
-        this.#onMessage({ type: "build-route-res", id, ok: false, error: reason });
-      else
-        this.#onMessage({ type: "build-csr-res", id, ok: false, error: reason });
-    }
+    for (const [id, type] of lost)
+      this.#onMessage({ type: `${type}-res`, id, ok: false, error: reason });
   }
   stop() {
     this.#manualStop = true;
@@ -541,7 +467,8 @@ class IncrementalBuilderHost {
   }
   static async create(app, env, onMessage, {
     stdio = "inherit",
-    onOutput
+    onOutput,
+    patcherOff = false
   } = {}) {
     const candidates = [
       path.join(app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
@@ -551,7 +478,7 @@ class IncrementalBuilderHost {
     ];
     for (const c of candidates)
       if (await Bun.file(c).exists())
-        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput });
+        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput, patcherOff });
     throw new Error(`[cli] frontend builder entry not found; looked in: ${candidates.join(", ")}`);
   }
 }
@@ -592,211 +519,7 @@ class BuilderRequestRouter {
 
 // pkgs/@akanjs/devkit/akanApp/BackendImportGraph.ts
 import { stat } from "fs/promises";
-import path3 from "path";
-
-// pkgs/@akanjs/devkit/akanApp/devHostPolicy.ts
 import path2 from "path";
-var BACKEND_RECOVERY_MAX_ATTEMPTS = 5;
-var HELD_BUILDER_REQUEST_LIMIT = 64;
-var BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS = 30000;
-var BUILDER_TIGHT_RSS_REPORT_LIMIT = 2;
-var BUILDER_RSS_HARD_MULTIPLE = 1.5;
-var DEV_IDLE_SUSPEND_MS = 300000;
-var DEV_IDLE_MIN_UPTIME_MS = 30000;
-var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-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 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 devHostStateByBackendState = {
-  starting: "starting",
-  ready: "ready",
-  "restart-pending": "restarting",
-  recovering: "recovering",
-  stopping: "stopped",
-  stopped: "stopped"
-};
-var devHostStateOf = (state, gaveUp) => state === "stopped" && gaveUp ? "failed" : devHostStateByBackendState[state];
-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 decideBuilderRssRecycle = ({
-  rssBytes,
-  ceilingBytes,
-  buildFailed,
-  msSinceLastRecycle,
-  minIntervalMs = BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS
-}) => {
-  if (!ceilingBytes)
-    return "unbounded";
-  if (rssBytes < ceilingBytes)
-    return "below-ceiling";
-  if (buildFailed)
-    return "build-failed";
-  if (msSinceLastRecycle !== null && msSinceLastRecycle < minIntervalMs)
-    return "too-soon";
-  return "recycle";
-};
-var decideBuilderRssSettle = ({
-  rssBytes,
-  ceilingBytes,
-  hardMultiple = BUILDER_RSS_HARD_MULTIPLE
-}) => rssBytes >= ceilingBytes * hardMultiple ? "recycle-now" : "wait-and-recheck";
-var decideIdleSuspend = ({
-  enabled,
-  suspended,
-  builderReady,
-  backendReady,
-  buildFailed,
-  restartPending,
-  msSinceWake,
-  minUptimeMs = DEV_IDLE_MIN_UPTIME_MS
-}) => {
-  if (!enabled)
-    return "disabled";
-  if (suspended)
-    return "already-suspended";
-  if (!builderReady)
-    return "builder-not-ready";
-  if (!backendReady)
-    return "backend-not-ready";
-  if (buildFailed)
-    return "build-failed";
-  if (restartPending)
-    return "restart-pending";
-  if (msSinceWake !== null && msSinceWake < minUptimeMs)
-    return "too-soon";
-  return "suspend";
-};
-var resolveIdleSuspendMs = (raw) => {
-  if (raw === undefined || raw === "")
-    return DEV_IDLE_SUSPEND_MS;
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed <= 0)
-    return null;
-  return Math.round(parsed);
-};
-var hasAnyBuildFailure = (statusByPhase) => [...statusByPhase.values()].some((status) => !status.ok);
-var shouldRefreshConfigOnIdleWake = (batch) => !!batch && batch.kinds.has("config");
-var RETURNING_BUILDER_STATUSES = new Set(["starting", "recycling", "restarting"]);
-var shouldHoldForReturningBuilder = ({
-  status,
-  heldCount,
-  limit = HELD_BUILDER_REQUEST_LIMIT
-}) => RETURNING_BUILDER_STATUSES.has(status) && heldCount < limit;
-var shouldWarnBuilderRssCeilingTight = (reportsSinceRecycle, limit = BUILDER_TIGHT_RSS_REPORT_LIMIT) => reportsSinceRecycle >= limit;
-var isRssCeilingUnreachable = (freshRssBytes, ceilingBytes) => freshRssBytes !== null && ceilingBytes !== null && freshRssBytes >= ceilingBytes;
-var shouldRelayRecycledFrontendState = (current, next) => {
-  if (!current || current.type !== next.type)
-    return true;
-  if (current.type === "pages-updated" && next.type === "pages-updated")
-    return current.data.bundlePath !== next.data.bundlePath;
-  if (current.type === "css-updated" && next.type === "css-updated")
-    return JSON.stringify(current.data.cssAssets) !== JSON.stringify(next.data.cssAssets);
-  return true;
-};
-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()];
-var filesChangedSince = (before, after) => [...before].filter(([file, stamp]) => after.get(file) !== stamp).map(([file]) => file);
-
-// pkgs/@akanjs/devkit/akanApp/BackendImportGraph.ts
 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 GRAPH_IMPORT_KINDS = new Set([
   "import-statement",
@@ -827,7 +550,7 @@ class BackendImportGraph {
     return this.#lastRefreshSucceeded;
   }
   has(file) {
-    return this.#files.has(path3.resolve(file));
+    return this.#files.has(path2.resolve(file));
   }
   async fingerprint() {
     const stamps = await Promise.all([...this.#files].map(async (file) => {
@@ -855,9 +578,9 @@ class BackendImportGraph {
     const roots = await this.#entrypoints();
     const files = new Set;
     const queue = [...roots];
-    const workspaceRoot = path3.resolve(this.#app.workspace.workspaceRoot);
+    const workspaceRoot = path2.resolve(this.#app.workspace.workspaceRoot);
     while (queue.length > 0) {
-      const current = path3.resolve(queue.pop());
+      const current = path2.resolve(queue.pop());
       if (files.has(current))
         continue;
       if (!this.#isWorkspaceSource(current, workspaceRoot))
@@ -866,7 +589,7 @@ class BackendImportGraph {
       if (!imports)
         continue;
       files.add(current);
-      const importerDir = path3.dirname(current);
+      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;
@@ -897,7 +620,7 @@ class BackendImportGraph {
     const roots = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     const existing = [];
     for (const root of roots) {
-      const abs = path3.resolve(root);
+      const abs = path2.resolve(root);
       if (await Bun.file(abs).exists())
         existing.push(abs);
     }
@@ -906,25 +629,25 @@ class BackendImportGraph {
   #resolve(specifier, importerDir) {
     try {
       const resolved = Bun.resolveSync(specifier, importerDir);
-      if (!path3.isAbsolute(resolved))
+      if (!path2.isAbsolute(resolved))
         return null;
-      if (!SOURCE_EXTS.has(path3.extname(resolved).toLowerCase()))
+      if (!SOURCE_EXTS.has(path2.extname(resolved).toLowerCase()))
         return null;
-      return path3.resolve(resolved);
+      return path2.resolve(resolved);
     } catch {
       return null;
     }
   }
   #isWorkspaceSource(file, workspaceRoot) {
-    const rel = path3.relative(workspaceRoot, file);
-    if (rel.startsWith("..") || path3.isAbsolute(rel))
+    const rel = path2.relative(workspaceRoot, file);
+    if (rel.startsWith("..") || path2.isAbsolute(rel))
       return false;
-    if (rel.includes(`${path3.sep}node_modules${path3.sep}`) || rel.includes(`${path3.sep}.akan${path3.sep}`))
+    if (rel.includes(`${path2.sep}node_modules${path2.sep}`) || rel.includes(`${path2.sep}.akan${path2.sep}`))
       return false;
-    return SOURCE_EXTS.has(path3.extname(file).toLowerCase());
+    return SOURCE_EXTS.has(path2.extname(file).toLowerCase());
   }
   #scanImports(file, source) {
-    const ext = path3.extname(file).toLowerCase();
+    const ext = path2.extname(file).toLowerCase();
     if (ext === ".tsx")
       return this.#tsxTranspiler.scanImports(source);
     if (ext === ".jsx")
@@ -935,8 +658,44 @@ class BackendImportGraph {
   }
 }
 
+// pkgs/@akanjs/devkit/akanApp/devBootLatch.ts
+class DevBootLatch {
+  #onBooted;
+  #waitMs;
+  #ready = false;
+  #armed = false;
+  #booted = false;
+  #timer = null;
+  constructor(onBooted, { waitMs = 30000 } = {}) {
+    this.#onBooted = onBooted;
+    this.#waitMs = waitMs;
+  }
+  ready() {
+    this.#ready = true;
+    if (!this.#armed && !this.#timer) {
+      this.#timer = setTimeout(() => this.armed(), this.#waitMs);
+      this.#timer.unref?.();
+    }
+    this.#release();
+  }
+  armed() {
+    this.#armed = true;
+    this.#release();
+  }
+  #release() {
+    if (this.#booted || !this.#ready || !this.#armed)
+      return;
+    this.#booted = true;
+    if (this.#timer)
+      clearTimeout(this.#timer);
+    this.#timer = null;
+    this.#onBooted();
+  }
+}
+
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
 var backendMsgTypeSet = new Set(["build-route", "build-csr"]);
+var asMib = (bytes) => Math.round(bytes / 1024 / 1024);
 var BACKEND_RESTART_DEBOUNCE_MS = 120;
 var BACKEND_GRACEFUL_TIMEOUT_MS = 8000;
 var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
@@ -952,13 +711,15 @@ var BUILDER_RECOVERY_MAX_DELAY_MS = 60000;
 
 class AkanAppHost {
   app;
-  logger = new Logger3("AkanAppHost");
+  logger = new Logger2("AkanAppHost");
   stdio;
   env;
   #onDevEvent;
   #lastDevState = null;
+  #bootLatch = new DevBootLatch(() => this.#onDevEvent?.({ app: this.app.name, booted: true }));
   #backend = null;
   #builder = null;
+  #patcherOff = false;
   #backendReady = false;
   #plannedBackendStops = new WeakSet;
   #restartTimer = null;
@@ -967,7 +728,10 @@ class AkanAppHost {
   #backendGaveUp = false;
   #backendLifecycleState = "stopped";
   #pendingRestartReason = null;
+  #backendRestart = null;
   #pendingRecycle = null;
+  #restartFailedAfterApply = null;
+  #stopping = false;
   #builderRecoveryTimer = null;
   #builderRecoveryAttempts = 0;
   #backendStartStatus = null;
@@ -995,6 +759,7 @@ class AkanAppHost {
   #builderGapStamp = null;
   #pendingBuilderMessages = [];
   #builderRequests = new BuilderRequestRouter;
+  #builderGeneration = 0;
   constructor(app, {
     env,
     stdio = "inherit",
@@ -1011,6 +776,8 @@ class AkanAppHost {
       return;
     this.#lastDevState = state;
     this.#onDevEvent({ app: this.app.name, state, ...detail ? { detail } : {} });
+    if (state === "ready")
+      this.#bootLatch.ready();
   }
   async start() {
     if (this.#backend)
@@ -1028,25 +795,24 @@ class AkanAppHost {
     return this;
   }
   async stop() {
+    this.#stopping = true;
+    this.#pendingRecycle = null;
     this.#cancelIdleSuspend();
     this.#stopIdleWatcher();
-    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.#clearRestartTimers();
+    this.#pendingRestartReason = null;
     this.#failPendingBuilderMessages("dev server is shutting down");
+    await this.#backendRestart;
     await this.#stopBackend();
     this.#stopBuilder();
     return this;
   }
+  #clearRestartTimers() {
+    for (const timer of [this.#restartTimer, this.#backendRecoveryTimer, this.#builderRecoveryTimer])
+      if (timer)
+        clearTimeout(timer);
+    this.#restartTimer = this.#backendRecoveryTimer = this.#builderRecoveryTimer = null;
+  }
   kill() {
     this.stop();
   }
@@ -1057,6 +823,12 @@ class AkanAppHost {
     return await createTunnel(type, { app: this.app, environment });
   }
   #startBackend(startStatus = null) {
+    if (this.#stopping)
+      return;
+    if (this.#backend) {
+      this.logger.warn(`backend pid=${this.#backend.pid} is still running; not starting a second one`);
+      return;
+    }
     this.#builderRequests.startGeneration();
     this.#discardPendingBuilderMessages("the backend restarted while the builder was away");
     this.#backendStartStatus = startStatus;
@@ -1077,6 +849,7 @@ class AkanAppHost {
           this.#setBackendLifecycleState("ready", `pid=${msg.pid}`);
           this.#recordBackendReadyStatus();
           this.logger.verbose(`backend ready pid=${msg.pid}`);
+          this.#forgetRouteBuildStatus();
           this.#replayBuilderState();
           return;
         }
@@ -1088,6 +861,8 @@ class AkanAppHost {
             message: msg.data.message
           });
           this.#sendOrQueueBuildStatus(status);
+          if (!status.ok)
+            this.#emitDevEvent("failed", status.message);
           return;
         }
         if (backendMsgTypeSet.has(msg.type))
@@ -1236,11 +1011,17 @@ class AkanAppHost {
       clearTimeout(this.#restartTimer);
     this.#restartTimer = setTimeout(() => {
       this.#restartTimer = null;
+      this.#backendRestart ??= this.#drainBackendRestarts().finally(() => {
+        this.#backendRestart = null;
+      });
+    }, BACKEND_RESTART_DEBOUNCE_MS);
+  }
+  async#drainBackendRestarts() {
+    while (this.#pendingRestartReason && !this.#restartTimer && !this.#stopping) {
       const next = this.#pendingRestartReason;
       this.#pendingRestartReason = null;
-      if (next)
-        this.#restartBackend(next);
-    }, BACKEND_RESTART_DEBOUNCE_MS);
+      await this.#restartBackend(next);
+    }
   }
   async#restartBackend(reason) {
     this.logger.verbose(`[backend-reload] restarting backend generation=${reason.generation ?? "(unknown)"} files=${reason.files.length} roles=${reason.roles.join(",") || "(none)"}`);
@@ -1297,17 +1078,26 @@ ${this.#backendStderrTail.join(`
     });
   }
   async#handleBuilderMessage(message) {
+    if (this.#stopping)
+      return;
     this.#markDevActivity();
+    this.#trackBuilderGeneration(message);
     if (message.type === "build-status") {
       this.#recordBuildStatus(message.data);
       this.#sendOrQueueBuildStatus(message.data);
       this.#reviveBackendAfterGreenBuild(message.data);
+      await this.#resumeFailedRecycle(message.data);
       return;
     }
     if (message.type === "builder-metrics") {
       this.#handleBuilderMetrics(message.data);
       return;
     }
+    if (message.type === "boot-armed") {
+      this.logger.verbose("[builder] boot builds settled");
+      this.#bootLatch.armed();
+      return;
+    }
     if (message.type === "pages-updated" || message.type === "css-updated") {
       const recycled = message.data.reason === "builder-recycle";
       if (recycled && !this.#shouldRelayRecycledState(message))
@@ -1329,6 +1119,22 @@ ${this.#backendStderrTail.join(`
     }
     this.#sendToBackend(message);
   }
+  #trackBuilderGeneration(message) {
+    const generation = AkanAppHost.#builderGenerationOf(message);
+    if (generation === undefined || generation <= this.#builderGeneration)
+      return;
+    this.#builderGeneration = generation;
+    Object.assign(this.env, { AKAN_BUILDER_INITIAL_GENERATION: String(generation) });
+  }
+  static #builderGenerationOf(message) {
+    if (message.type === "invalidate")
+      return message.generation;
+    if (message.type === "build-status" || message.type === "builder-metrics")
+      return message.data.generation;
+    if (message.type === "pages-updated" || message.type === "css-updated")
+      return message.data.generation;
+    return;
+  }
   #shouldRelayRecycledState(message) {
     const current = message.type === "pages-updated" ? this.#lastGoodFrontend.pages : this.#lastGoodFrontend.css;
     if (shouldRelayRecycledFrontendState(current, message)) {
@@ -1342,7 +1148,6 @@ ${this.#backendStderrTail.join(`
     if (this.#rssCeilingAbandoned)
       return;
     const ceilingBytes = IncrementalBuilderHost.maxRssBytes();
-    const asMib = (bytes) => Math.round(bytes / 1024 / 1024);
     const decision = decideBuilderRssRecycle({
       rssBytes: metrics.rssBytes,
       ceilingBytes,
@@ -1380,7 +1185,6 @@ ${this.#backendStderrTail.join(`
     if (!isRssCeilingUnreachable(freshRssBytes, ceilingBytes))
       return;
     this.#rssCeilingAbandoned = true;
-    const asMib = (bytes) => Math.round(bytes / 1024 / 1024);
     this.logger.error(`[builder-recycle] a freshly recycled builder is already at ${asMib(freshRssBytes ?? 0)}MiB with nothing built on demand, so the ${asMib(ceilingBytes)}MiB ceiling cannot be met for this app; no longer enforcing it this session. Raise AKAN_BUILDER_MAX_RSS_MB, or set it to 0 to leave the builder unbounded.`);
   }
   #armRssRecycle(reason, over) {
@@ -1407,7 +1211,6 @@ ${this.#backendStderrTail.join(`
     }, BUILDER_RSS_RECYCLE_QUIET_MS);
   }
   async#recycleBuilderForRssWhenStillOver(reason, { rssBytes, ceilingBytes }) {
-    const asMib = (bytes) => Math.round(bytes / 1024 / 1024);
     if (decideBuilderRssSettle({ rssBytes, ceilingBytes }) === "recycle-now") {
       this.#recycleBuilderForRss(reason);
       return;
@@ -1433,16 +1236,18 @@ ${this.#backendStderrTail.join(`
     this.#recycleBuilderForRss(settledBytes === null ? reason : `${reason}; still ${asMib(settledBytes)}MiB after settling`);
   }
   static async readProcessRssBytes(pid) {
+    if (process.platform === "win32")
+      return await AkanAppHost.#readRssKbVia(["tasklist", "/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], AkanAppHost.#tasklistRssKb);
     const status = await Bun.file(`/proc/${pid}/status`).text().catch(() => null);
     const vmRssKb = status === null ? null : /VmRSS:\s+(\d+) kB/.exec(status)?.[1];
     if (vmRssKb)
       return Number(vmRssKb) * 1024;
-    return await AkanAppHost.#readRssViaPs(pid);
+    return await AkanAppHost.#readRssKbVia(["ps", "-o", "rss=", "-p", String(pid)], (output) => Number(output.trim()));
   }
-  static async#readRssViaPs(pid, timeoutMs = PS_RSS_TIMEOUT_MS) {
+  static async#readRssKbVia(command, parseKb, timeoutMs = PS_RSS_TIMEOUT_MS) {
     let proc;
     try {
-      proc = Bun.spawn(["ps", "-o", "rss=", "-p", String(pid)], { stdio: ["ignore", "pipe", "ignore"] });
+      proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"] });
     } catch {
       return null;
     }
@@ -1450,7 +1255,7 @@ ${this.#backendStderrTail.join(`
     try {
       const output = await new Response(proc.stdout).text();
       await proc.exited;
-      const rssKb = Number(output.trim());
+      const rssKb = parseKb(output);
       return Number.isFinite(rssKb) && rssKb > 0 ? rssKb * 1024 : null;
     } catch {
       return null;
@@ -1458,6 +1263,10 @@ ${this.#backendStderrTail.join(`
       clearTimeout(killer);
     }
   }
+  static #tasklistRssKb(output) {
+    const memUsage = /"([^"]*)"\s*$/m.exec(output)?.[1];
+    return memUsage ? Number(memUsage.replace(/\D/g, "")) : Number.NaN;
+  }
   #cancelRssRecycle() {
     this.#rssRecycleReason = null;
     this.#rssRecycleOver = null;
@@ -1517,7 +1326,7 @@ ${this.#backendStderrTail.join(`
     this.logger.info(`[idle-suspend] no build activity for ${Math.round(idleMs / 1000)}s; released the builder \u2014 the next edit or route request brings it back`);
   }
   get #restartPending() {
-    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
+    return !!(this.#pendingRecycle || this.#restartTimer || this.#backendRestart || this.#backendRecoveryTimer || this.#builderRecoveryTimer || this.#rssRecycleReason);
   }
   async#startIdleWatcher() {
     try {
@@ -1584,16 +1393,14 @@ ${this.#backendStderrTail.join(`
     if (shouldRefreshConfigOnIdleWake(batch)) {
       this.logger.verbose("[idle-suspend] config changed while suspended; restarting the dev host");
       this.#discardBuilderGap("config change replaces the backend anyway");
-      await this.#recycleDevChildren({ type: "invalidate", kinds: [...batch?.kinds ?? []], files }, {
-        refreshConfig: true
-      });
+      await this.#applyRecycle({ type: "invalidate", kinds: [...batch?.kinds ?? []], files }, true);
       return;
     }
     if (files.length > 0)
       await this.#backendGraph.refresh();
     await this.#startBuilder({ announceBootState: true });
     const missed = await this.#takeBuilderGapChanges();
-    const backendFiles = [...new Set([...files.filter((file) => this.#isBackendFile(file)), ...missed])];
+    const backendFiles = [...new Set([...files.filter((file) => this.#backendGraph.has(file)), ...missed])];
     if (backendFiles.length === 0)
       return;
     this.logger.verbose(`[idle-suspend] ${backendFiles.length} backend file(s) changed while suspended`);
@@ -1648,10 +1455,6 @@ ${this.#backendStderrTail.join(`
     for (const message of pending)
       this.#sendToBuilder(message);
   }
-  #holdUntilBuilderReady(message) {
-    this.#pendingBuilderMessages.push(message);
-    this.logger.verbose(`[builder] holding ${message.type} until the builder is ready (${this.#pendingBuilderMessages.length} waiting)`);
-  }
   #discardPendingBuilderMessages(reason) {
     const held = this.#pendingBuilderMessages.splice(0);
     if (held.length === 0)
@@ -1663,12 +1466,17 @@ ${this.#backendStderrTail.join(`
     if (held.length === 0)
       return;
     this.logger.warn(`failing ${held.length} held builder request(s): ${reason}`);
-    for (const message of held) {
-      if (message.type === "build-route")
-        this.#sendToBackend({ type: "build-route-res", id: message.id, ok: false, error: reason });
-      else if (message.type === "build-csr")
-        this.#sendToBackend({ type: "build-csr-res", id: message.id, ok: false, error: reason });
-    }
+    for (const message of held)
+      this.#failBuilderRequest(message, reason);
+  }
+  #failBuilderRequest(message, error) {
+    if (message.type === "build-route")
+      this.#sendToBackend({ type: "build-route-res", id: message.id, ok: false, error });
+    else if (message.type === "build-csr")
+      this.#sendToBackend({ type: "build-csr-res", id: message.id, ok: false, error });
+    else
+      return false;
+    return true;
   }
   #recycleBuilderForRss(reason) {
     if (this.#pendingRecycle || this.#restartTimer) {
@@ -1686,7 +1494,8 @@ ${this.#backendStderrTail.join(`
       this.#armRssRecycle(this.#rssRecycleReason);
     const wantsDevHostRestart = shouldRestartDevHostByDevPlan(message);
     const pending = this.#pendingRecycle;
-    if (wantsDevHostRestart || shouldRestartBuilderByDevPlan(message) || pending && message.kinds.includes("code")) {
+    const resumes = !!pending && message.kinds.includes("code") && this.#touchesFailedRecycle(message.files);
+    if (wantsDevHostRestart || shouldRestartBuilderByDevPlan(message) || resumes) {
       const refreshConfig = wantsDevHostRestart || (pending?.refreshConfig ?? false);
       const merged = pending ? mergeInvalidateMessages(pending.message, message) : message;
       const generation = message.devPlan?.generation ?? message.generation;
@@ -1694,16 +1503,7 @@ ${this.#backendStderrTail.join(`
         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);
-      }
+      await this.#applyRecycle(merged, refreshConfig);
       return;
     }
     if (await this.#shouldRestartBackend(message)) {
@@ -1712,6 +1512,41 @@ ${this.#backendStderrTail.join(`
     }
     this.#sendToBackend(message);
   }
+  async#applyRecycle(message, refreshConfig) {
+    if (this.#stopping)
+      return;
+    this.#pendingRecycle = null;
+    const progress = { applied: !refreshConfig };
+    try {
+      if (refreshConfig)
+        await this.#restartDevHost(message, progress);
+      else
+        await this.#restartDevChildren(message);
+    } catch (err) {
+      const kind = refreshConfig ? "Config" : "Runtime metadata";
+      const generation = this.#recordDevHostRestartFailure(message, err, kind, { applied: progress.applied });
+      if (progress.applied)
+        this.#restartFailedAfterApply = generation;
+      else
+        this.#pendingRecycle = { message, refreshConfig, failed: true, failedGeneration: generation };
+      this.#resurrectDevChildren(message);
+    }
+  }
+  async#resumeFailedRecycle(status) {
+    const pending = this.#pendingRecycle;
+    if (!pending?.failed || !status.ok || status.phase !== "pages" || !this.#touchesFailedRecycle(status.files))
+      return;
+    if (status.generation <= (pending.failedGeneration ?? -1))
+      return;
+    await this.#applyRecycle(pending.message, pending.refreshConfig);
+  }
+  #touchesFailedRecycle(files) {
+    const pending = this.#pendingRecycle;
+    if (!pending?.failed)
+      return true;
+    const changed = new Set(pending.message.files);
+    return files.some((file) => changed.has(file));
+  }
   #deferRecycle(message, { refreshConfig, generation }) {
     this.#pendingRecycle = { message, refreshConfig };
     const kind = refreshConfig ? "Config" : "Runtime metadata";
@@ -1757,8 +1592,10 @@ ${this.#backendStderrTail.join(`
     this.#builderRecoveryAttempts = 0;
     this.logger.info("[builder-recovery] builder recovered");
     this.#restartBackendForGapChanges();
+    const failedAfterApply = this.#restartFailedAfterApply;
+    this.#restartFailedAfterApply = null;
     const status = {
-      generation: reason.generation ?? this.#nextBackendBuildStatusGeneration(),
+      generation: failedAfterApply !== null ? this.#nextBackendBuildStatusGeneration(failedAfterApply + 1) : reason.generation ?? this.#nextBackendBuildStatusGeneration(),
       phase: "scan",
       ok: true,
       files: reason.files,
@@ -1782,36 +1619,29 @@ ${this.#backendStderrTail.join(`
     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) {
+  async#restartDevHost(message, progress) {
     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 });
+    await this.#recycleDevChildren(message, { refreshConfig: true, progress });
   }
-  async#recycleDevChildren(message, { refreshConfig = false } = {}) {
+  async#recycleDevChildren(message, { refreshConfig = false, progress } = {}) {
     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.#clearRestartTimers();
     this.#builderRecoveryAttempts = 0;
     this.#pendingRestartReason = null;
+    await this.#backendRestart;
     this.#lastGoodFrontend = {};
     this.#buildStatusByPhase.clear();
     this.#pendingBuildStatusReplay = [];
     await this.#stopBackend();
     this.#stopBuilder();
+    this.#patcherOff = false;
     if (refreshConfig) {
       await this.app.getConfig({ refresh: true });
       const { env } = await this.app.prepareCommand("start");
       Object.assign(this.env, env);
+      if (progress)
+        progress.applied = true;
     }
     await this.#backendGraph.refresh();
     await this.#startBuilder();
@@ -1830,22 +1660,27 @@ ${this.#backendStderrTail.join(`
     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) {
+  #recordDevHostRestartFailure(message, err, kind, { applied }) {
     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 names = message.files.slice(0, 3).map((file) => path3.basename(file));
+    const saved = names.length > 0 ? names.join(", ") : "the changed file";
     const status = {
       generation,
       phase: "scan",
       ok: false,
       files: message.files,
-      message: `${kind} change failed to apply; recovering the dev server automatically: ${detail}`
+      message: applied ? `${kind} change applied, but the dev server failed to restart: ${detail}. It is recovering on its own.` : `${kind} change failed to apply: ${detail}. The dev server keeps running on the previous ${kind.toLowerCase()}; once it is fixed, save ${saved} again or restart the dev server to apply it.`
     };
     this.#recordBuildStatus(status);
     this.#sendOrQueueBuildStatus(status);
+    return generation;
   }
   #recordBuildStatus(status) {
     const recovered = shouldMarkBuildPhaseRecovered(this.#buildStatusByPhase, status);
+    if (shouldKeepBuildFailure(this.#buildStatusByPhase, status))
+      return;
     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)
@@ -1861,6 +1696,10 @@ ${this.#backendStderrTail.join(`
     }
     this.#sendToBackend({ type: "build-status", data: status });
   }
+  #forgetRouteBuildStatus() {
+    this.#buildStatusByPhase.delete("route");
+    this.#pendingBuildStatusReplay = this.#pendingBuildStatusReplay.filter((status) => status.phase !== "route");
+  }
   #replayBuilderState() {
     if (!this.#backendReady)
       return;
@@ -1890,7 +1729,7 @@ ${this.#backendStderrTail.join(`
     }
     if (message.kinds.includes("code"))
       await this.#backendGraph.refresh();
-    if (message.files.some((file) => this.#isBackendFile(file)))
+    if (message.files.some((file) => this.#backendGraph.has(file)))
       return true;
     if (!this.#backendGraph.lastRefreshSucceeded) {
       const fallbackFiles = message.files.filter((file) => isLegacyBackendFallbackFile(file, this.app.workspace.workspaceRoot));
@@ -1901,9 +1740,6 @@ ${this.#backendStderrTail.join(`
     }
     return false;
   }
-  #isBackendFile(file) {
-    return this.#backendGraph.has(file);
-  }
   async#startBuilder({
     announceBootState = false
   } = {}) {
@@ -1915,7 +1751,8 @@ ${this.#backendStderrTail.join(`
         this.#enqueueBuilderMessage(msg);
       }, {
         stdio: this.stdio,
-        onOutput: (kind, text) => void (kind === "stderr" ? process.stderr : process.stdout).write(text)
+        onOutput: (kind, text) => void (kind === "stderr" ? process.stderr : process.stdout).write(text),
+        patcherOff: this.#patcherOff
       });
       try {
         await this.#waitForBuilderReady(attempt, { announceBootState });
@@ -1989,33 +1826,20 @@ ${this.#backendStderrTail.join(`
       return;
     const status = this.#builder?.status ?? "stopped";
     if (shouldHoldForReturningBuilder({ status, heldCount: this.#pendingBuilderMessages.length })) {
-      this.#holdUntilBuilderReady(message);
-      return;
-    }
-    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`
-      });
+      this.#pendingBuilderMessages.push(message);
+      this.logger.verbose(`[builder] holding ${message.type} until the builder is ready (${this.#pendingBuilderMessages.length} waiting)`);
       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`
-      });
+    if (this.#failBuilderRequest(message, `builder is ${status}; reload after the builder is ready`))
       return;
-    }
     this.logger.warn("akanAppHost builder is not running");
   }
   #stopBuilder() {
     this.#cancelRssRecycle();
     if (!this.#builder)
       return;
+    if (this.#builder.patcherOff)
+      this.#patcherOff = true;
     this.#builder.stop();
     this.#builder = null;
   }
@@ -2025,21 +1849,16 @@ import path4 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
-  const addResolvedPackageCandidate = (basePath) => {
+  for (const basePath of [target.cwdPath, process.cwd(), path4.dirname(Bun.main), import.meta.dir]) {
     try {
       candidates.push(path4.join(path4.dirname(Bun.resolveSync("akanjs/package.json", basePath)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
-  };
-  addResolvedPackageCandidate(target.cwdPath);
-  addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path4.dirname(Bun.main));
-  addResolvedPackageCandidate(import.meta.dir);
+  }
   candidates.push(path4.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path4.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path4.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path4.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path4.join(path4.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path4.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
   const uniqueCandidates = [...new Set(candidates)];
-  for (const candidate of uniqueCandidates) {
+  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(`
@@ -2047,21 +1866,17 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 }
 
 // pkgs/@akanjs/cli/application/application.runner.ts
-import { Logger as Logger4 } from "akanjs/common";
-import ora from "ora";
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-kxwbssgn.js")).ApplicationBuildRunner;
-var loadReleasePackager = async () => (await import("./applicationReleasePackager-4yasxwv9.js")).ApplicationReleasePackager;
-var loadCapacitorApp = async () => (await import("./capacitorApp-36rbr858.js")).CapacitorApp;
-var loadAbstractCompactor = async () => (await import("./abstractCompactor-gmkc0z8j.js")).AbstractCompactor;
+import { Logger as Logger3 } from "akanjs/common";
+var loadBuildRunner = async () => (await import("./applicationBuildRunner-64taxseg.js")).ApplicationBuildRunner;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
-  async createApplication(appName, workspace, libs = []) {
+  async createApplication(appName, workspace, libs = [], { sample = false } = {}) {
     await workspace.applyTemplate({
       basePath: `apps/${appName}`,
       template: "app",
       dict: { appName },
-      options: { libs }
+      options: { libs, sample }
     });
     return AppExecutor.from(workspace, appName);
   }
@@ -2071,9 +1886,6 @@ class ApplicationRunner extends runner("application") {
   async removeApplication(app) {
     await app.workspace.removeDir(`apps/${app.name}`);
   }
-  async getConfig(app) {
-    return await app.getConfig();
-  }
   async getScriptFilename(app) {
     if (!await app.exists("script")) {
       await app.mkdir("script");
@@ -2095,7 +1907,7 @@ class ApplicationRunner extends runner("application") {
     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" }),
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script", ...await app.getDatabaseModeEnv() }),
       stdio: "inherit"
     });
   }
@@ -2110,13 +1922,10 @@ class ApplicationRunner extends runner("application") {
     const { level, grep, endpoint, trace, child, role, origin, since } = options;
     const query = Object.fromEntries(Object.entries({ level, grep, endpoint, trace, child, role, origin, since }).filter(([, value]) => value !== undefined && value !== null && value !== ""));
     const print = (record) => process.stdout.write(options.json ? `${JSON.stringify(record)}
-` : Logger4.render(record));
+` : Logger3.render(record));
     const note = (text) => process.stderr.write(`[akan logs] ${text}
 `);
-    let finish = null;
-    const closed = new Promise((resolve) => {
-      finish = resolve;
-    });
+    const { promise: closed, resolve: finish } = Promise.withResolvers();
     let client;
     try {
       client = await LogTailClient.connect(socketPath, {
@@ -2125,7 +1934,7 @@ class ApplicationRunner extends runner("application") {
           if (response.type === "dropped")
             note(`${response.count} records dropped (reader too slow)`);
         },
-        onClose: () => finish?.()
+        onClose: () => finish()
       });
     } catch (error) {
       if (error instanceof LogControlUnavailableError)
@@ -2167,7 +1976,7 @@ 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);
+assertAkanConsoleAllowed();
 await server.start({ listen: false, web: false });
 try {
   await startAkanConsole(server, {
@@ -2186,17 +1995,35 @@ try {
 }
 `;
     await app.spawn("bun", ["-e", code], {
-      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console" }),
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "console", ...await app.getDatabaseModeEnv() }),
+      stdio: "inherit"
+    });
+  }
+  async transferDatabase(app, direction, dir) {
+    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 target = path5.resolve(app.workspace.workspaceRoot, dir);
+    const code = `
+const { server } = await import(${JSON.stringify(serverPath)});
+const { DatabaseAdaptorRole, DocumentTransfer } = await import("akanjs/service");
+await server.start({ listen: false, web: false });
+try {
+  const transfer = new DocumentTransfer(server.get(DatabaseAdaptorRole));
+  const reports = await transfer.${direction === "export" ? "exportTo" : "importFrom"}(${JSON.stringify(target)});
+  for (const { table, rows } of reports) console.info(\`${direction === "export" ? "exported" : "imported"} \${table}: \${rows} rows\`);
+} finally {
+  await server.stop();
+}
+`;
+    await app.spawn("bun", ["-e", code], {
+      env: app.getCommandEnv({ AKAN_COMMAND_TYPE: "script", ...await app.getDatabaseModeEnv() }),
       stdio: "inherit"
     });
   }
   async typecheck(app, options = {}) {
     await new (await loadBuildRunner())(app).typecheck(options);
   }
-  async compact(sys, { module, minLines, interactive } = {}) {
-    const compactor = new (await loadAbstractCompactor())(sys, { minLines, interactive });
-    return await compactor.compactAll({ module });
-  }
   async test(exec) {
     const isSignalTarget = exec instanceof AppExecutor || exec instanceof LibExecutor;
     const preloadPath = isSignalTarget ? await resolveSignalTestPreloadPath(exec) : null;
@@ -2232,72 +2059,188 @@ try {
       setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
     return appHost;
   }
-  async buildIos(app, { target, env = "debug", regenerate = false } = {}) {
+  async buildMobile(app, platform, { target, env = "debug", profile = "release", installer = false, arch } = {}) {
     const targets = await resolveMobileTargets(app, target);
-    await this.#buildMobileCsr(app, env);
+    NativeApp.assertInstaller(platform, installer);
+    if (arch && platform !== "macos" && platform !== "windows" && platform !== "linux")
+      throw new Error(`--arch picks a desktop app's CPU; ${platform} builds for its own.`);
+    if (arch === "x64" && platform === "macos")
+      throw new Error("A macOS app is built for Apple silicon (arm64) only.");
+    const carried = await this.#stageMobile(app, platform, targets, env, arch);
     await this.#runMobileTargets(targets, async (mobileTarget) => {
-      await new (await loadCapacitorApp())(app, mobileTarget.config).buildIos({ env, regenerate });
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).build(platform, {
+        profile,
+        ...carried && ApplicationRunner.carriesServer(mobileTarget, platform) ? { server: carried } : {},
+        ...installer ? { installer } : {},
+        ...arch ? { arch } : {}
+      }));
     });
   }
-  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 buildDesktop(app, options = {}) {
+    await this.buildMobile(app, NativeApp.desktopPlatform(), options);
+  }
+  async startMobile(app, platform, { target, env = "local", operation = "local", device, teamId, interrupt } = {}) {
+    const mobileTarget = await ApplicationRunner.startTarget(app, platform, target);
+    const nativeApp = new NativeApp(app, mobileTarget, env);
+    const selection = { ...device ? { device } : {}, ...teamId ? { teamId } : {} };
+    if (operation === "release") {
+      const carried = await this.#stageMobile(app, platform, [mobileTarget], env);
+      const running = await nativeApp.run(platform, {
+        ...selection,
+        profile: "release",
+        ...carried ? { server: carried } : {}
+      });
+      await running.exited;
+      return;
+    }
+    const upstream = `http://localhost:${await app.getDevPort()}`;
+    if (!await ApplicationRunner.answers(upstream, app.name, app.workspace.workspaceRoot))
+      throw new Error(`No dev server answers on ${upstream}; run \`akan start ${app.name}\` first.`);
+    const { i18n } = await app.getConfig();
+    const session = await nativeApp.dev(platform, { upstream, lang: i18n.defaultLocale, ...selection });
+    if (interrupt)
+      interrupt.add(async () => await session.stop(), "Abandoning the app's shutdown; its window may stay open.", 130);
+    else
+      process.once("SIGINT", () => {
+        session.stop().finally(() => process.exit(130));
+      });
+    await session.exited;
   }
-  async releaseIos(app, { target, env = "main", regenerate = false } = {}) {
+  async startDesktop(app, options = {}) {
+    await this.startMobile(app, NativeApp.desktopPlatform(), options);
+  }
+  static async startTarget(app, platform = NativeApp.desktopPlatform(), target) {
     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 });
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error(`start-${platform === "ios" || platform === "android" ? platform : "desktop"} runs one native target at a time; pass --target <name>.`);
+    return mobileTarget;
+  }
+  static async answers(url, appName, workspaceRoot) {
+    const signal = AbortSignal.timeout(3000);
+    const health = await fetch(new URL("/_akan/app/health", url), { signal }).catch(() => null);
+    if (!health)
+      return false;
+    const info = await fetch(new URL("/_akan/app/info", url), { signal }).then(async (res) => res.ok ? await res.json() : null).catch(() => null);
+    const stopIt = `Stop it (\`akan start ${appName} --kill\` takes the port over) or give ${appName} another port with AKAN_DEV_PORT`;
+    if (info?.appName === appName) {
+      if (typeof info.workspaceRoot !== "string" || ApplicationRunner.#sameCheckout(info.workspaceRoot, workspaceRoot))
+        return true;
+      throw new Error(`${url} is the dev server of ${appName} in ${info.workspaceRoot}, not in ${workspaceRoot}. ${stopIt}.`);
     }
+    if (typeof info?.appName === "string")
+      throw new Error(`${url} is the dev server of ${info.appName}, not ${appName}. ${stopIt}.`);
+    const { pid } = await health.json().catch(() => null) ?? {};
+    throw new Error(typeof pid === "number" ? `${url} is an akan dev server (pid ${pid}) too old to say which app it serves. ${stopIt}.` : `${url} answers, but not as an akan dev server. Stop what holds the port or give ${appName} another port with AKAN_DEV_PORT.`);
   }
-  async buildAndroid(app, { target, env = "debug", regenerate = false } = {}) {
+  static #sameCheckout(reported, own) {
+    const canonical = (root) => {
+      try {
+        return realpathSync.native(root);
+      } catch {
+        return path5.resolve(root);
+      }
+    };
+    return canonical(reported) === canonical(own);
+  }
+  async releaseIos(app, { target, env = "main", teamId, adHoc = 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 });
-    });
+    for (const mobileTarget of targets)
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseIos({ teamId, adHoc }));
   }
-  async startAndroid(app, {
-    open = false,
-    operation = "local",
-    env = "local",
-    target,
-    regenerate = false
-  } = {}) {
+  async releaseAndroid(app, format, { target, env = "main" } = {}) {
     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();
-    });
+    NativeApp.androidSigning();
+    await this.#buildMobileCsr(app, env);
+    for (const mobileTarget of targets)
+      this.#reportBuild(app, mobileTarget, await new NativeApp(app, mobileTarget, env).releaseAndroid({ formats: [format] }));
   }
-  async releaseAndroid(app, assembleType, { target, env = "main", regenerate = false } = {}) {
+  async packUpdate(app, platform, { target, env = "main", out, against }) {
     const targets = await resolveMobileTargets(app, target);
+    const [mobileTarget] = targets;
+    if (!mobileTarget || targets.length > 1)
+      throw new Error("pack-update packs one native target at a time; pass --target <name>.");
     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`);
+    const packed = await new NativeApp(app, mobileTarget, env).packUpdate(platform, { out });
+    const size = packed.manifest.files.reduce((sum, file) => sum + file.size, 0);
+    app.logger.info(`packed ${mobileTarget.name} ${platform} for channel '${packed.channel}' to ${packed.out}: ${packed.manifest.files.length} files, ${(size / 1024).toFixed(0)} KiB, native API ${packed.manifest.nativeApi}`);
+    if (!against)
+      return;
+    const bundle = path5.join(packed.out, "bundle.json");
+    const compat = await NativeApp.compareBundles(app.cwdPath, against, bundle);
+    await Bun.write(path5.join(packed.out, "compat.json"), `${JSON.stringify({ against, ...compat }, null, 2)}
+`);
+    if (!compat.compatible)
+      throw new Error(`This bundle needs a new store build; the one ${against} came from provides another native API:
+- ${compat.problems.join(`
+- `)}`);
+    app.logger.info(`runs in the store build of ${against}`);
+  }
+  async updateKeygen(app, platform, target) {
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    const seen = new Set;
+    for (const mobileTarget of await resolveMobileTargets(app, target ?? "all")) {
+      const appId = resolveAppId(mobileTarget.config.appId, nativePlatform);
+      if (seen.has(appId))
+        continue;
+      seen.add(appId);
+      const { publicKey, keyPath, created } = await new NativeApp(app, mobileTarget).updateKeygen(nativePlatform);
+      app.log(`${appId}: ${created ? "made" : "read"} ${keyPath}${created ? " (keep it private and backed up: without it, installed apps take no more updates)" : ""}`);
+      app.log(`  native: { updates: { url: "https://\u2026/${app.name}", publicKey: ${JSON.stringify(publicKey)} } }`);
+      const declared = mobileTarget.config.updates?.publicKey;
+      if (declared && declared !== publicKey)
+        app.logger.warn(`native.targets.${mobileTarget.name}.updates.publicKey is another key's; releases would not verify.`);
     }
   }
+  async publishUpdate(app, platform, { target, env = "main", channel } = {}) {
+    const targets = await resolveMobileTargets(app, target);
+    const nativePlatform = platform === "desktop" ? NativeApp.desktopPlatform() : platform;
+    for (const mobileTarget of targets)
+      await new NativeApp(app, mobileTarget, env).assertPublishable(nativePlatform, {
+        server: ApplicationRunner.carriesServer(mobileTarget, nativePlatform),
+        ...channel ? { channel } : {}
+      });
+    const carried = await this.#stageMobile(app, nativePlatform, targets, env);
+    for (const mobileTarget of targets) {
+      const nativeApp = new NativeApp(app, mobileTarget, env);
+      const published = await nativeApp.publishUpdate(nativePlatform, {
+        ...channel ? { channel } : {},
+        ...carried && ApplicationRunner.carriesServer(mobileTarget, nativePlatform) ? { server: carried } : {}
+      });
+      this.#reportBuild(app, mobileTarget, published.build);
+      app.log(`${app.name}/${mobileTarget.name} ${published.bundle}: ${published.dir}/${published.channel}.json, ${published.files} files, ${Math.round(published.size / 1024)} KiB`);
+      app.log(`Upload ${nativeApp.updatesDir} to ${mobileTarget.config.updates?.url}, the manifests last.`);
+    }
+  }
+  #reportBuild(app, mobileTarget, { artifacts, warnings, signing }) {
+    for (const warning of warnings)
+      app.logger.warn(warning);
+    if (signing)
+      app.log(`Signed with ${signing.identity} (${signing.profile}, team ${signing.teamId})`);
+    for (const artifact of artifacts)
+      app.log(`${app.name}/${mobileTarget.name} ${artifact.kind}: ${artifact.path}`);
+  }
+  static carriesServer({ config }, platform = NativeApp.desktopPlatform()) {
+    return platform !== "ios" && platform !== "android" && !!config.desktop?.server;
+  }
+  static serverOmit(targets, platform) {
+    const carrying = targets.filter((target) => ApplicationRunner.carriesServer(target, platform));
+    const omits = carrying.map(({ config }) => {
+      const server = config.desktop?.server;
+      return typeof server === "object" ? server.omit ?? [] : [];
+    });
+    const [first = [], ...rest] = omits;
+    if (rest.some((omit) => omit.join("\x00") !== first.join("\x00")))
+      throw new Error(`The targets that carry the server omit different packages (${carrying.map(({ name }, idx) => `${name}: ${omits[idx]?.join(", ") || "none"}`).join("; ")}); build them one --target at a time.`);
+    return first;
+  }
+  async#stageMobile(app, platform, targets, env, arch) {
+    const stage = targets.some((mobileTarget) => ApplicationRunner.carriesServer(mobileTarget, platform)) ? new DesktopServerStage(app) : null;
+    await stage?.install(arch, ApplicationRunner.serverOmit(targets, platform));
+    await this.#buildMobileCsr(app, env);
+    return await stage?.prepare(env);
+  }
   async#buildMobileCsr(app, env) {
     const prevEnv = {
       AKAN_PUBLIC_ENV: process.env.AKAN_PUBLIC_ENV,
@@ -2310,7 +2253,7 @@ try {
       APP_OPERATION_MODE: "release"
     });
     try {
-      await new (await loadBuildRunner())(app).build({ spinner: true });
+      await new (await loadBuildRunner())(app, { environment: env }).build({ spinner: true });
     } finally {
       for (const [key, value] of Object.entries(prevEnv)) {
         if (value === undefined)
@@ -2335,24 +2278,23 @@ try {
       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");
+      Logger3.rawLog(`Native 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();
+    throw new Error(`${failures.length}/${results.length} native targets failed`);
   }
   #getLocalDatabaseServices(mode) {
     if (mode === "single")
       return [];
     if (mode === "multiple")
-      return ["redis", "libsql"];
+      return ["redis"];
     return ["redis", "postgres"];
   }
+  async#assertComposeHas(workspace, services) {
+    const compose = Bun.YAML.parse(await Bun.file(`${workspace.workspaceRoot}/local/docker-compose.yaml`).text());
+    const missing = services.filter((service) => !compose?.services?.[service]);
+    if (missing.length)
+      throw new Error(`local/docker-compose.yaml declares no ${missing.join(" or ")} service. Add it, or move the file aside so the next akan dbup writes the current template.`);
+  }
   async#isLocalDatabaseUp(workspace, mode) {
     const requiredServices = this.#getLocalDatabaseServices(mode);
     if (!requiredServices.length)
@@ -2366,16 +2308,18 @@ try {
   async dbup(workspace, mode = "multiple") {
     if (mode === "single")
       return true;
+    const services = this.#getLocalDatabaseServices(mode);
+    await workspace.applyTemplate({
+      basePath: "local",
+      template: "localDev",
+      dict: { repoName: workspace.repoName },
+      overwrite: false
+    });
+    await this.#assertComposeHas(workspace, services);
     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)], {
+        await workspace.spawn(`docker`, ["compose", "up", "-d", ...services], {
           cwd: `${workspace.workspaceRoot}/local`
         });
       return wasAlreadyUp;
@@ -2393,74 +2337,182 @@ ${detail}`
   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;
+}
+
+// pkgs/@akanjs/cli/application/hostProcessProbe.ts
+import { readdirSync, readFileSync, readlinkSync } from "fs";
+
+class HostProcessProbe {
+  static timeoutMs = 3000;
+  static win32TimeoutMs = 20000;
+  static #procTcpListen = "0A";
+  static #win32ProcessQuery = "[Console]::OutputEncoding=[Text.Encoding]::UTF8; Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress";
+  platform;
+  #win32Table = null;
+  constructor(platform = process.platform) {
+    this.platform = platform;
+  }
+  async listenersOn(port) {
+    if (this.platform === "win32")
+      return HostProcessProbe.parseNetstat(await HostProcessProbe.run(["netstat", "-ano"]), port);
+    if (this.platform === "linux")
+      return HostProcessProbe.#procListenersOn(port);
+    const output = await HostProcessProbe.run(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
+    return [
+      ...new Set(output.split(`
+`).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0))
+    ];
   }
-  async createApplicationTemplate(workspace, appName) {
-    await workspace.applyTemplate({ basePath: `apps/${appName}`, template: "appRoot", dict: { appName } });
+  async parentOf(pid) {
+    if (this.platform === "win32") {
+      const child = await this.#win32Process(pid);
+      const parent = child ? await this.#win32Process(child.ppid) : null;
+      return child && parent ? HostProcessProbe.parentPidOf(child, parent) : null;
+    }
+    if (this.platform === "linux") {
+      const stat = HostProcessProbe.#readProc(pid, "stat");
+      return stat === null ? null : HostProcessProbe.parseProcStatPpid(stat);
+    }
+    const parsed = Number((await HostProcessProbe.run(["ps", "-p", String(pid), "-o", "ppid="])).trim());
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
   }
-  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 commandOf(pid) {
+    if (this.platform === "win32")
+      return (await this.#win32Process(pid))?.command ?? null;
+    if (this.platform === "linux") {
+      const cmdline = HostProcessProbe.#readProc(pid, "cmdline");
+      return cmdline?.split("\x00").filter(Boolean).join(" ") || null;
+    }
+    return (await HostProcessProbe.run(["ps", "-ww", "-p", String(pid), "-o", "command="])).trim() || null;
   }
-  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!");
+  static parentPidOf(child, parent) {
+    if (child.ppid !== parent.pid)
+      return null;
+    if (parent.startedAt !== null && child.startedAt !== null && parent.startedAt > child.startedAt)
+      return null;
+    return parent.pid;
+  }
+  static parseNetstat(output, port) {
+    const pids = new Set;
+    for (const line of output.split(/\r?\n/)) {
+      const fields = line.trim().split(/\s+/);
+      if (fields[0] !== "TCP" || fields.length < 5)
+        continue;
+      const [, local, remote] = fields;
+      if (!local?.endsWith(`:${port}`) || !remote?.endsWith(":0"))
+        continue;
+      const pid = Number(fields.at(-1));
+      if (Number.isInteger(pid) && pid > 0)
+        pids.add(pid);
+    }
+    return [...pids];
+  }
+  static parseProcNetTcp(text, port) {
+    const inodes = [];
+    for (const line of text.split(`
+`).slice(1)) {
+      const fields = line.trim().split(/\s+/);
+      const [, local, , state, , , , , , inode] = fields;
+      if (!local || !inode || state !== HostProcessProbe.#procTcpListen || inode === "0")
+        continue;
+      if (Number.parseInt(local.slice(local.lastIndexOf(":") + 1), 16) === port)
+        inodes.push(inode);
+    }
+    return inodes;
+  }
+  static parseProcStatPpid(stat) {
+    const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
+    return Number.isInteger(ppid) && ppid > 0 ? ppid : null;
+  }
+  static parseWin32Processes(json) {
+    const table = new Map;
+    let parsed;
+    try {
+      parsed = JSON.parse(json.trim() || "[]");
+    } catch {
+      return table;
+    }
+    const rows = Array.isArray(parsed) ? parsed : [parsed];
+    for (const row of rows) {
+      if (typeof row?.ProcessId !== "number")
+        continue;
+      table.set(row.ProcessId, {
+        pid: row.ProcessId,
+        ppid: row.ParentProcessId ?? 0,
+        command: row.CommandLine?.trim() || null,
+        startedAt: HostProcessProbe.#parseCimDate(row.CreationDate)
+      });
+    }
+    return table;
+  }
+  static async run(command, timeoutMs = HostProcessProbe.timeoutMs) {
+    let proc;
+    try {
+      proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+    } catch {
+      return "";
+    }
+    const timer = setTimeout(() => proc.kill("SIGKILL"), timeoutMs);
+    try {
+      return await new Response(proc.stdout).text();
+    } catch {
+      return "";
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async#win32Process(pid) {
+    this.#win32Table ??= await HostProcessProbe.#queryWin32Processes();
+    if (!this.#win32Table.has(pid))
+      this.#win32Table = await HostProcessProbe.#queryWin32Processes();
+    return this.#win32Table.get(pid) ?? null;
+  }
+  static async#queryWin32Processes() {
+    const output = await HostProcessProbe.run(["powershell", "-NoProfile", "-NonInteractive", "-Command", HostProcessProbe.#win32ProcessQuery], HostProcessProbe.win32TimeoutMs);
+    return HostProcessProbe.parseWin32Processes(output);
+  }
+  static #parseCimDate(value) {
+    if (!value)
+      return null;
+    const legacy = /\/Date\((\d+)/.exec(value)?.[1];
+    const ms = legacy ? Number(legacy) : Date.parse(value);
+    return Number.isFinite(ms) ? ms : null;
+  }
+  static #procListenersOn(port) {
+    const inodes = new Set(["tcp", "tcp6"].flatMap((table) => HostProcessProbe.parseProcNetTcp(HostProcessProbe.#readProc("net", table) ?? "", port)));
+    if (!inodes.size)
+      return [];
+    const pids = [];
+    for (const entry of HostProcessProbe.#listDir("/proc")) {
+      if (!/^\d+$/.test(entry))
+        continue;
+      const holds = HostProcessProbe.#listDir(`/proc/${entry}/fd`).some((fd) => {
+        const link = HostProcessProbe.#orElse(() => readlinkSync(`/proc/${entry}/fd/${fd}`), "");
+        const inode = /^socket:\[(\d+)\]$/.exec(link)?.[1];
+        return !!inode && inodes.has(inode);
+      });
+      if (holds)
+        pids.push(Number(entry));
+    }
+    return pids;
+  }
+  static #readProc(pid, file) {
+    return HostProcessProbe.#orElse(() => readFileSync(`/proc/${pid}/${file}`, "utf8"), null);
+  }
+  static #listDir(dir) {
+    return HostProcessProbe.#orElse(() => readdirSync(dir), []);
+  }
+  static #orElse(read, fallback) {
+    try {
+      return read();
+    } catch {
+      return fallback;
+    }
   }
 }
 
 // pkgs/@akanjs/cli/application/devPortReclaimer.ts
 class DevPortReclaimer {
-  static lsofTimeoutMs = 3000;
   static releaseTimeoutMs = 8000;
   static maxAncestorDepth = 8;
   static #releasePollMs = 100;
@@ -2469,7 +2521,12 @@ class DevPortReclaimer {
     return [...new Set(ports.flatMap((port) => [port, port + DevPortReclaimer.wsPortOffset]))].sort((left, right) => left - right);
   }
   static isAkanCommand(command) {
-    return /(^|\/)akan(\s|$)/.test(command) || command.includes("@akanjs/cli") || command.includes("akanjs/server") || /\bapps\/[^/\s]+\/main\.ts\b/.test(command) || command.includes("incrementalBuilder.proc") || command.includes("rscWorker");
+    const normalized = command.replaceAll("\\", "/");
+    return /(^|\/)akan(\.exe)?"?(\s|$)/.test(normalized) || normalized.includes("@akanjs/cli") || normalized.includes("akanjs/server") || /\bapps\/[^/\s]+\/main\.ts\b/.test(normalized) || normalized.includes("incrementalBuilder.proc") || normalized.includes("rscWorker");
+  }
+  #probe;
+  constructor(probe = new HostProcessProbe) {
+    this.#probe = probe;
   }
   async reclaim(ports) {
     const killed = [];
@@ -2494,10 +2551,10 @@ class DevPortReclaimer {
   }
   async holdersOf(port) {
     const holders = [];
-    for (const listenerPid of await this.#pidsOn(port)) {
+    for (const listenerPid of await this.#probe.listenersOn(port)) {
       if (listenerPid === process.pid || listenerPid === process.ppid)
         continue;
-      const command = await this.#commandOf(listenerPid);
+      const command = await this.#probe.commandOf(listenerPid);
       if (!command)
         continue;
       if (!DevPortReclaimer.isAkanCommand(command)) {
@@ -2512,44 +2569,37 @@ class DevPortReclaimer {
   async#akanRootOf(pid, command) {
     let root = { pid, command };
     for (let depth = 0;depth < DevPortReclaimer.maxAncestorDepth; depth += 1) {
-      const parentPid = await this.#ppidOf(root.pid);
+      const parentPid = await this.#probe.parentOf(root.pid);
       if (parentPid === null || parentPid <= 1 || parentPid === process.pid || parentPid === process.ppid)
         break;
-      const parentCommand = await this.#commandOf(parentPid);
+      const parentCommand = await this.#probe.commandOf(parentPid);
       if (!parentCommand || !DevPortReclaimer.isAkanCommand(parentCommand))
         break;
       root = { pid: parentPid, command: parentCommand };
     }
     return root;
   }
-  async#ppidOf(pid) {
-    const output = await this.#run(["ps", "-p", String(pid), "-o", "ppid="]);
-    const parsed = Number(output.trim());
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
-  }
-  async#pidsOn(port) {
-    const output = await this.#run(["lsof", "-ti", `tcp:${port}`, "-sTCP:LISTEN"]);
-    return [
-      ...new Set(output.split(`
-`).map((line) => Number(line.trim())).filter((pid) => Number.isInteger(pid) && pid > 0))
-    ];
-  }
-  async#commandOf(pid) {
-    const output = await this.#run(["ps", "-p", String(pid), "-o", "command="]);
-    return output.trim() || null;
-  }
   async#terminate(pid) {
+    if (this.#probe.platform === "win32") {
+      await HostProcessProbe.run(["taskkill", "/PID", String(pid), "/T", "/F"]);
+      return await this.#released(pid);
+    }
     if (!this.#signal(pid, "SIGTERM"))
       return !this.#alive(pid);
+    if (await this.#released(pid))
+      return true;
+    this.#signal(pid, "SIGKILL");
+    await Bun.sleep(DevPortReclaimer.#releasePollMs);
+    return !this.#alive(pid);
+  }
+  async#released(pid) {
     const deadline = Date.now() + DevPortReclaimer.releaseTimeoutMs;
     while (Date.now() < deadline) {
       if (!this.#alive(pid))
         return true;
       await Bun.sleep(DevPortReclaimer.#releasePollMs);
     }
-    this.#signal(pid, "SIGKILL");
-    await Bun.sleep(DevPortReclaimer.#releasePollMs);
-    return !this.#alive(pid);
+    return false;
   }
   #signal(pid, signal) {
     try {
@@ -2567,26 +2617,15 @@ class DevPortReclaimer {
       return error.code === "EPERM";
     }
   }
-  async#run(command) {
-    const proc = Bun.spawn(command, { stdio: ["ignore", "pipe", "ignore"] });
-    const timer = setTimeout(() => proc.kill("SIGKILL"), DevPortReclaimer.lsofTimeoutMs);
-    try {
-      return await new Response(proc.stdout).text();
-    } catch {
-      return "";
-    } finally {
-      clearTimeout(timer);
-    }
-  }
 }
 
 // pkgs/@akanjs/cli/application/devStreamView.ts
-import { Logger as Logger5 } from "akanjs/common";
+import { Logger as Logger4 } from "akanjs/common";
 import chalk from "chalk";
 var appColors = ["cyan", "magenta", "yellow", "green", "blue", "red"];
 
 class DevStreamView {
-  #logger = new Logger5("akan start");
+  #logger = new Logger4("akan start");
   #partial = new Map;
   #lastState = new Map;
   #color = new Map;
@@ -2656,7 +2695,7 @@ import os from "os";
 import { MemoryLimit as MemoryLimit2 } from "akanjs/server/memoryLimit";
 
 class DevBootConcurrency {
-  static perAppBytes = 900 * 1024 * 1024;
+  static perAppBytes = 1800 * 1024 * 1024;
   static memoryShare = 0.5;
   static coresPerApp = 4;
   static budget() {
@@ -2692,6 +2731,7 @@ class DevBootConcurrency {
 import { mkdir, rename } from "fs/promises";
 import path6 from "path";
 import dayjs from "dayjs";
+
 class DevSessionLog {
   static fileName = "dev.log";
   static previousFileName = "dev.prev.log";
@@ -2792,6 +2832,16 @@ class DevSessionLog {
 
 // pkgs/@akanjs/cli/application/devSupervisor.ts
 class DevSupervisor {
+  static resolveDevUi(plain, {
+    isTty = !!process.stdout.isTTY,
+    columns = process.stdout.columns ?? 0
+  } = {}) {
+    if (plain)
+      return { mode: "stream", downgraded: false };
+    if (!isTty || columns <= 0)
+      return { mode: "stream", downgraded: true };
+    return { mode: "tui", downgraded: false };
+  }
   static supervisedEnvKey = "AKAN_DEV_SUPERVISED";
   static childHooks() {
     if (process.env[DevSupervisor.supervisedEnvKey] !== "1" || !process.send)
@@ -2806,7 +2856,7 @@ class DevSupervisor {
       }
     };
   }
-  static readyTimeoutMs = 180000;
+  static bootTimeoutMs = 180000;
   static shutdownGraceMs = 12000;
   #options;
   #children = new Map;
@@ -2855,23 +2905,21 @@ class DevSupervisor {
     return ports;
   }
   #makeChild(app, port) {
-    let markReady;
-    const ready = new Promise((resolve) => {
-      markReady = resolve;
-    });
+    const { promise: booted, resolve: markBooted } = Promise.withResolvers();
     return {
       status: {
         app,
         name: app.name,
         port,
         url: `http://localhost:${port}`,
+        shareUrl: this.#options.shares?.get(app.name) ?? null,
         state: "starting",
         detail: "queued",
         exitCode: null
       },
       proc: null,
-      ready,
-      markReady,
+      booted,
+      markBooted,
       opened: false
     };
   }
@@ -2890,20 +2938,22 @@ class DevSupervisor {
       for (const child of wave)
         this.#spawnChild(child);
       this.#publishStatus();
-      await Promise.all(wave.map(async (child) => await this.#waitForReady(child)));
+      await Promise.all(wave.map(async (child) => await this.#waitForBoot(child)));
     }
   }
-  async#waitForReady(child) {
-    let timer = null;
+  async#waitForBoot(child) {
+    if (await DevSupervisor.timesOut(child.booted, DevSupervisor.bootTimeoutMs))
+      this.#note(`${child.status.name} has not finished booting after ${Math.round(DevSupervisor.bootTimeoutMs / 1000)}s; starting the next app anyway`, "warn");
+  }
+  static async timesOut(work, ms) {
+    let timer;
     const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("expired"), DevSupervisor.readyTimeoutMs);
+      timer = setTimeout(() => resolve(true), ms);
     });
     try {
-      if (await Promise.race([child.ready.then(() => "ready"), expired]) === "expired")
-        this.#note(`${child.status.name} has not reported ready after ${Math.round(DevSupervisor.readyTimeoutMs / 1000)}s; starting the next app anyway`, "warn");
+      return await Promise.race([work.then(() => false), expired]);
     } finally {
-      if (timer)
-        clearTimeout(timer);
+      clearTimeout(timer);
     }
   }
   static childArgs(name, { write = true } = {}) {
@@ -2930,9 +2980,12 @@ class DevSupervisor {
       },
       stdio: ["ignore", "pipe", "pipe"],
       ipc: (message) => {
-        if (!message || typeof message !== "object" || typeof message.state !== "string")
+        if (!message || typeof message !== "object")
           return;
-        this.#applyChildEvent(child, message);
+        if ("booted" in message)
+          child.markBooted();
+        else if (typeof message.state === "string")
+          this.#applyChildEvent(child, message);
       },
       serialization: "advanced",
       onExit: (_proc, exitCode, signalCode) => {
@@ -2942,7 +2995,7 @@ class DevSupervisor {
           return;
         child.status.state = "stopped";
         child.status.detail = signalCode ? `killed by ${signalCode}` : `exited with ${exitCode}`;
-        child.markReady();
+        child.markBooted();
         this.#publishStatus();
       }
     });
@@ -2956,14 +3009,13 @@ class DevSupervisor {
     child.status.state = event.state;
     child.status.detail = event.detail ?? "";
     if (event.state === "ready") {
-      child.markReady();
       if (this.#options.open && !child.opened) {
         child.opened = true;
         openBrowser(child.status.url);
       }
     }
     if (event.state === "failed")
-      child.markReady();
+      child.markBooted();
     this.#publishStatus();
   }
   async#drain(stream, name, kind) {
@@ -3025,44 +3077,81 @@ class DevSupervisor {
     for (const child of running)
       child.proc.kill("SIGTERM");
     const exited = Promise.all(running.map(async (child) => await child.proc.exited));
-    let timer = null;
-    const expired = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("expired"), DevSupervisor.shutdownGraceMs);
-    });
-    try {
-      if (await Promise.race([exited.then(() => "exited"), expired]) === "expired") {
-        for (const child of running) {
-          if (!child.proc.killed) {
-            this.#note(`${child.status.name} did not exit in time; killing it`, "warn");
-            child.proc.kill("SIGKILL");
-          }
-        }
-      }
-    } finally {
-      if (timer)
-        clearTimeout(timer);
+    if (!await DevSupervisor.timesOut(exited, DevSupervisor.shutdownGraceMs))
+      return;
+    for (const child of running) {
+      if (child.proc.killed)
+        continue;
+      this.#note(`${child.status.name} did not exit in time; killing it`, "warn");
+      child.proc.kill("SIGKILL");
     }
   }
 }
 
-// pkgs/@akanjs/cli/application/devUiMode.ts
-var resolveDevUi = (plain, { isTty = !!process.stdout.isTTY, columns = process.stdout.columns ?? 0 } = {}) => {
-  if (plain)
-    return { mode: "stream", downgraded: false };
-  if (!isTty || columns <= 0)
-    return { mode: "stream", downgraded: true };
-  return { mode: "tui", downgraded: false };
-};
+// pkgs/@akanjs/cli/application/interruptTeardown.ts
+import { Logger as Logger5 } from "akanjs/common";
+
+class InterruptTeardown {
+  #teardowns = [];
+  #exit;
+  #listen;
+  #report;
+  #interrupted = false;
+  #chain = Promise.resolve();
+  ownsExit = true;
+  constructor({ exit, listen, report } = {}) {
+    this.#exit = exit ?? ((code) => process.exit(code));
+    this.#listen = listen ?? ((onSignal) => {
+      process.on("SIGINT", onSignal);
+    });
+    this.#report = report ?? ((message) => Logger5.rawLog(message, undefined, "error"));
+  }
+  add(run, abandoned, exitCode = 0) {
+    this.#teardowns.push({ run, abandoned, exitCode, state: "pending" });
+    if (this.#teardowns.length === 1)
+      this.#listen(() => this.#onSignal());
+  }
+  async runAll() {
+    await this.#runTeardowns();
+  }
+  #onSignal() {
+    if (this.#interrupted) {
+      for (const one of this.#teardowns)
+        if (one.state !== "done")
+          this.#report(one.abandoned);
+      this.#exit(130);
+      return;
+    }
+    this.#interrupted = true;
+    this.#runTeardowns().finally(() => {
+      if (this.ownsExit)
+        this.#exit(Math.max(0, ...this.#teardowns.map((one) => one.exitCode)));
+    });
+  }
+  async#runTeardowns() {
+    this.#chain = this.#chain.then(async () => {
+      for (const one of this.#teardowns.toReversed()) {
+        if (one.state !== "pending")
+          continue;
+        one.state = "running";
+        await one.run().catch(() => {
+          return;
+        });
+        one.state = "done";
+      }
+    });
+    await this.#chain;
+  }
+}
 
 // pkgs/@akanjs/cli/application/application.script.ts
 class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
   static dbShutdownTimeoutMs = 20000;
+  static devServerReadyTimeoutMs = DevSupervisor.bootTimeoutMs;
+  #interrupt = new InterruptTeardown;
   async confirmDatabaseModeDependencyInstall(databaseMode, installSpecs) {
     return await confirm({
-      message: [
-        `Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}.`,
-        "Install them now?"
-      ].join(" "),
+      message: `Database mode '${databaseMode}' requires missing dependencies: ${installSpecs.join(", ")}. Install them now?`,
       default: true
     });
   }
@@ -3073,67 +3162,22 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     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;
-    }
+    await this.#addDependencies(app, installSpecs, `database dependencies for ${databaseMode} mode`);
   }
-  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...");
+  async#addDependencies(app, installSpecs, what) {
+    const spinner = app.workspace.spinning(`Installing ${what}...`);
     try {
-      await app.workspace.spawn("bun", ["add", ...installSpecs], {
-        stdio: "inherit"
-      });
+      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(", ")}`);
+      spinner.succeed(`Installed ${what}`);
     } catch (error) {
-      spinner.fail(`Failed to add default Capacitor plugins to ${app.name}`);
+      spinner.fail(`Failed to install ${what}`);
       throw error;
     }
   }
-  async createApplication(appName, workspace, { start = false, libs = [] } = {}) {
+  async createApplication(appName, workspace, { start = false, libs = [], sample = false } = {}) {
     const spinner = workspace.spinning("Creating application...");
-    const app = await this.applicationRunner.createApplication(appName, workspace, libs);
+    const app = await this.applicationRunner.createApplication(appName, workspace, libs, { sample });
     spinner.succeed(`Application created in apps/${app.name}`);
     await app.scanSync();
     if (start)
@@ -3156,17 +3200,6 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     else
       await this.libraryScript.syncLibrary(sys);
   }
-  async compact(sys, { module = null, minLines, interactive = false } = {}) {
-    const { scanned, reports } = await this.applicationRunner.compact(sys, { module, minLines, interactive });
-    if (!reports.length) {
-      Logger6.rawLog(`No abstract file long enough to compact in ${sys.name} (${scanned} scanned)`);
-      return;
-    }
-    for (const report of reports)
-      Logger6.rawLog(`${report.status}: ${report.path} (${report.beforeLines} -> ${report.afterLines} lines)`);
-    const compactedNum = reports.filter((report) => report.status === "compacted").length;
-    Logger6.rawLog(`Compacted ${compactedNum}/${reports.length} abstract files in ${sys.name}`);
-  }
   async script(app, filename) {
     const scriptFilename = filename ?? await this.applicationRunner.getScriptFilename(app);
     await app.scanSync();
@@ -3184,10 +3217,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     if (!quiet)
       Logger6.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
-      const result = await this.applicationRunner.build(app, {
-        fast,
-        spinner: !quiet
-      });
+      const result = await this.applicationRunner.build(app, { fast, spinner: !quiet });
       Logger6.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
@@ -3212,8 +3242,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async test(exec, { write = true } = {}) {
     if (exec instanceof LibExecutor) {
       await this.libraryScript.syncLibrary(exec);
-      const spinner = exec.spinning(`Preparing ${exec.name}...`);
-      spinner.succeed(`${exec.name} prepared`);
+      exec.spinning(`Preparing ${exec.name}...`).succeed(`${exec.name} prepared`);
       await this.applicationRunner.test(exec);
       return;
     }
@@ -3230,23 +3259,33 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     }
     await this.applicationRunner.test(exec);
   }
-  async start(apps, { open = false, dbup = true, write = true, plain = false, kill = false, concurrency = null } = {}) {
+  async start(apps, {
+    open = false,
+    dbup = true,
+    write = true,
+    plain = false,
+    kill = false,
+    share = false,
+    concurrency = null
+  } = {}) {
     const first = apps[0];
     if (!first)
       throw new Error("No app selected to start");
-    const { mode, downgraded } = resolveDevUi(plain);
+    const { mode, downgraded } = DevSupervisor.resolveDevUi(plain);
     if (downgraded)
       first.workspace.log("no sized terminal to draw on; printing prefixed lines instead");
     if (kill)
       await this.reclaimDevPorts(apps);
+    const shares = share ? await this.#shareOnInterrupt(apps) : null;
     if (mode === "stream" && apps.length === 1)
       return await this.startOne(first, { open, dbup, write, ...DevSupervisor.childHooks() });
-    await this.#startMany(apps, { open, dbup, write, mode, concurrency });
+    this.#interrupt.ownsExit = false;
+    await this.#startMany(apps, { open, dbup, write, mode, concurrency, shares });
   }
   async startOne(app, { open = false, dbup = true, stdio = "inherit", write = true, onDevEvent } = {}) {
     await app.scanSync({ write });
     const akanConfig = await app.getConfig();
-    const databaseMode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+    const databaseMode = akanConfig.resolveDatabaseMode();
     await this.syncDatabaseModeDependencies(app, akanConfig, databaseMode);
     if (app.getEnv() === "local" && dbup && databaseMode !== "single") {
       const wasDbAlreadyUp = await this.dbup(app.workspace, databaseMode);
@@ -3254,15 +3293,12 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
         this.#stopDatabaseOnInterrupt(app.workspace);
     }
     const spinner = app.spinning("Preparing backend...");
-    const akanAppHost = await this.applicationRunner.start(app, {
+    return await this.applicationRunner.start(app, {
       open,
-      onStart: () => {
-        spinner.succeed(`${app.name} prepared, ready to start`);
-      },
+      onStart: () => spinner.succeed(`${app.name} prepared, ready to start`),
       onDevEvent,
       stdio
     });
-    return akanAppHost;
   }
   async reclaimDevPorts(apps) {
     const workspace = apps[0]?.workspace;
@@ -3277,13 +3313,20 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     if (killed.length === 0 && foreign.length === 0)
       workspace.log("dev ports are free; nothing to kill");
   }
-  async#startMany(apps, { open, dbup, write, mode, concurrency }) {
+  async#startMany(apps, {
+    open,
+    dbup,
+    write,
+    mode,
+    concurrency,
+    shares
+  }) {
     const workspace = apps[0]?.workspace;
     if (!workspace)
       throw new Error("No app selected to start");
     const startedDatabase = dbup ? await this.#prepareSharedDatabase(apps) : false;
-    const supervisor = new DevSupervisor({ apps, mode, concurrency, open, write });
-    const view = mode === "tui" ? await (await import("./devTuiView-0hc2emhe.js")).createDevTuiView(supervisor) : new DevStreamView(apps.map((app) => app.name));
+    const supervisor = new DevSupervisor({ apps, mode, concurrency, open, write, shares });
+    const view = mode === "tui" ? new (await import("./devTui-q7k7bakd.js")).DevTui(supervisor) : new DevStreamView(apps.map((app) => app.name));
     await supervisor.run(view);
     if (startedDatabase)
       await this.#stopDatabase(workspace);
@@ -3297,7 +3340,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       if (app.getEnv() !== "local")
         continue;
       const akanConfig = await app.getConfig();
-      const mode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+      const mode = akanConfig.resolveDatabaseMode();
       await this.syncDatabaseModeDependencies(app, akanConfig, mode);
       if (mode !== "single")
         modes.add(mode);
@@ -3308,82 +3351,121 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
         started = true;
     return started;
   }
-  async buildIos(app, { write = true, target, env = "debug", regenerate = false } = {}) {
+  async buildIos(app, { write = true, ...options } = {}) {
     await app.scanSync({ write });
-    await this.applicationRunner.buildIos(app, { target, env, regenerate });
+    await this.applicationRunner.buildMobile(app, "ios", options);
   }
-  async startIos(app, {
-    open = false,
-    operation = "local",
-    env = "local",
-    write = true,
-    target,
-    device,
-    regenerate = false,
-    noAllowProvisioningUpdates = false
-  } = {}) {
+  async buildAndroid(app, { write = true, ...options } = {}) {
     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
+    await this.applicationRunner.buildMobile(app, "android", options);
+  }
+  async buildDesktop(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.buildDesktop(app, options);
+  }
+  async startIos(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.startMobile(app, "ios", options);
+  }
+  async startAndroid(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    await this.applicationRunner.startMobile(app, "android", options);
+  }
+  async startDesktop(app, { write = true, ...options } = {}) {
+    await app.scanSync({ write });
+    if (options.operation === "release")
+      return await this.applicationRunner.startDesktop(app, options);
+    const mobileTarget = await ApplicationRunner.startTarget(app, undefined, options.target);
+    if (!ApplicationRunner.carriesServer(mobileTarget))
+      return await this.applicationRunner.startDesktop(app, options);
+    DesktopServerStage.assertCarriable(await app.getConfig());
+    const upstream = `http://localhost:${await app.getDevPort()}`;
+    try {
+      if (await ApplicationRunner.answers(upstream, app.name, app.workspace.workspaceRoot))
+        app.log(`The desktop app follows the dev server on ${upstream}.`);
+      else
+        await this.#startDevServerFor(app, upstream);
+      await this.applicationRunner.startDesktop(app, { ...options, interrupt: this.#interrupt });
+    } finally {
+      await this.#interrupt.runAll();
+    }
+  }
+  async#startDevServerFor(app, upstream) {
+    app.log(`No dev server answers on ${upstream}; starting \`akan start ${app.name}\` for the desktop app.`);
+    let settle = () => {};
+    const settled = new Promise((resolve) => settle = resolve);
+    const appHost = await this.startOne(app, {
+      write: false,
+      onDevEvent: (event) => {
+        if ("state" in event && (event.state === "ready" || event.state === "failed"))
+          settle(event.state);
+      }
     });
+    this.#interrupt.add(async () => {
+      await appHost.stop();
+    }, "Abandoning the dev server shutdown; its processes may still be running.", 130);
+    let state;
+    const timedOut = await DevSupervisor.timesOut(settled.then((settledState) => state = settledState), ApplicationScript.devServerReadyTimeoutMs);
+    if (state === "ready")
+      return;
+    await this.#interrupt.runAll();
+    throw new Error(timedOut ? `akan start ${app.name} did not answer within ${ApplicationScript.devServerReadyTimeoutMs / 1000}s; see its log above.` : `akan start ${app.name} gave up restarting its server; see its log above.`);
   }
-  async releaseIos(app, { write = true, target, env = "main", regenerate = false, allowLocalRelease = false } = {}) {
+  async releaseIos(app, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
     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 });
+    ApplicationScript.#assertReleaseEnv("releaseIos", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.releaseIos(app, options);
   }
-  async buildAndroid(app, { write = true, target, env = "debug", regenerate = false } = {}) {
+  async releaseAndroid(app, format, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
     await app.scanSync({ write });
-    await this.applicationRunner.buildAndroid(app, { target, env, regenerate });
+    ApplicationScript.#assertReleaseEnv("releaseAndroid", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.releaseAndroid(app, format, options);
   }
-  async startAndroid(app, {
-    open = false,
-    operation = "local",
-    env = "local",
+  async packUpdate(app, platform, {
     write = true,
-    target,
-    regenerate = false
+    allowLocalRelease = false,
+    ...options
   } = {}) {
     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
-    });
+    ApplicationScript.#assertReleaseEnv("packUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.packUpdate(app, platform, options);
+  }
+  async updateKeygen(app, platform, { target } = {}) {
+    await this.applicationRunner.updateKeygen(app, platform, target);
   }
-  async releaseAndroid(app, assembleType, { write = true, target, env = "main", regenerate = false, allowLocalRelease = false } = {}) {
+  async publishUpdate(app, platform, {
+    write = true,
+    allowLocalRelease = false,
+    ...options
+  } = {}) {
     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
-    });
+    ApplicationScript.#assertReleaseEnv("publishUpdate", options.env ?? "main", allowLocalRelease);
+    await this.applicationRunner.publishUpdate(app, platform, options);
   }
-  async configureApp(app) {
-    await this.applicationRunner.configureApp(app);
+  static #assertReleaseEnv(command, env, allowLocalRelease) {
+    if (env === "local" && !allowLocalRelease)
+      throw new Error(`${command} --env local is blocked. Pass allowLocalRelease only for explicit local release testing.`);
   }
-  async releaseSource(app, options) {
-    await this.applicationRunner.releaseSource(app, options);
+  async transferDatabase(app, direction, dir) {
+    await this.applicationRunner.transferDatabase(app, direction, dir);
   }
-  async codepush(app, os) {
-    await this.applicationRunner.codepush(app, os);
+  async dbupDeclared(workspace, mode) {
+    const declared = mode ? [mode] : await Promise.all((await workspace.getApps()).map(async (appName) => (await AppExecutor.from(workspace, appName).getConfig()).database.modes)).then((modes) => [...new Set(modes.flat())]);
+    const needing = declared.filter((each) => each !== "single");
+    if (!needing.length) {
+      workspace.log("No app here declares a database mode that runs on local services; single needs none.");
+      return;
+    }
+    for (const each of needing)
+      await this.dbup(workspace, each);
   }
   async dbup(workspace, mode = "multiple") {
     const spinner = workspace.spinning(`Starting local database (${mode})...`);
@@ -3401,34 +3483,36 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     }
     spinner.succeed("Local database (/local/docker-compose.yaml) is down");
   }
-  #stopDatabaseOnInterrupt(workspace) {
-    let stopping = false;
-    process.on("SIGINT", () => {
-      if (stopping) {
-        Logger6.rawLog("Abandoning the local database teardown; containers are left running.", undefined, "error");
-        process.exit(130);
-      }
-      stopping = true;
-      this.#stopDatabase(workspace).finally(() => process.exit(0));
+  async#shareOnInterrupt(apps) {
+    const shares = [];
+    const urls = new Map;
+    this.#interrupt.add(async () => {
+      await Promise.all(shares.map(async (share) => await share.close()));
+    }, "Abandoning the tunnel release; the shares expire on their own.");
+    await Promise.all(apps.map(async (app) => {
+      const { TunnelShare } = await import("./TunnelShare-cwh9ezsm.js");
+      const share = await TunnelShare.open(app, { workspace: app.workspace });
+      shares.push(share);
+      urls.set(app.name, share.url);
+      Logger6.rawLog(`${app.name} is shared at ${share.url}`);
+    })).catch((error) => {
+      Logger6.rawLog(`Could not open the tunnel: ${error instanceof Error ? error.message : String(error)}`, undefined, "error");
     });
+    return urls;
+  }
+  #stopDatabaseOnInterrupt(workspace) {
+    this.#interrupt.add(async () => {
+      await this.#stopDatabase(workspace);
+    }, "Abandoning the local database teardown; containers are left running.");
   }
   async#stopDatabase(workspace) {
-    let timer = null;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve("timeout"), ApplicationScript.dbShutdownTimeoutMs);
+    const stopped = this.dbdown(workspace).catch(() => {
+      return;
     });
-    try {
-      const result = await Promise.race([this.dbdown(workspace).catch(() => {
-        return;
-      }), timeout]);
-      if (result !== "timeout")
-        return;
-      Logger6.rawLog(`Local database did not stop within ${ApplicationScript.dbShutdownTimeoutMs}ms; run \`akan dbdown\` once Docker responds.`, undefined, "error");
-    } finally {
-      if (timer)
-        clearTimeout(timer);
-    }
+    if (!await DevSupervisor.timesOut(stopped, ApplicationScript.dbShutdownTimeoutMs))
+      return;
+    Logger6.rawLog(`Local database did not stop within ${ApplicationScript.dbShutdownTimeoutMs}ms; run \`akan dbdown\` once Docker responds.`, undefined, "error");
   }
 }
 
-export { openBrowser, plainTextOf, HOST_SOURCE, DevLogBuffer, ApplicationScript };
+export { ApplicationScript };