@akanjs/cli 3.0.0-alpha.11 → 3.0.0-alpha.111

package/{index-bzznxgcx.js → index-v0qh106m.js}

@@ -1,27 +1,123 @@
 // @bun
-import {
-  LibraryScript
-} from "./index-8pd02prk.js";
-import {
-  resolveMobileTargets
-} from "./index-76rn3g2c.js";
 import {
   runner,
   script
-} from "./index-etwh7sd3.js";
+} from "./index-mak3cd28.js";
+import {
+  WorkspaceExecutor,
+  AppExecutor,
+  LibExecutor,
+  PkgExecutor
+} from "./index-2tv3fdx4.js";
+import {
+  LibraryScript
+} from "./index-259dsnz3.js";
 import {
   HmrWatcher,
   WatchRootResolver
-} from "./index-bjpxzr6s.js";
+} from "./index-hwkygn9s.js";
 import {
-  AppExecutor,
-  LibExecutor,
-  PkgExecutor,
-  WorkspaceExecutor
-} from "./index-yzsxc30b.js";
+  SlicePlanner,
+  formatSlicePlan
+} from "./index-j9yhg404.js";
 import {
-  __require
-} from "./index-r24hmh0q.js";
+  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";
@@ -70,11 +166,12 @@ Caused by: ${ApplicationBuildReporter.formatError(error.cause)}` : "";
 
 // pkgs/@akanjs/cli/application/application.script.ts
 import { confirm } from "@inquirer/prompts";
-import { Logger as Logger5 } from "akanjs/common";
+import { Logger as Logger6 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/application/application.runner.ts
+import path5 from "path";
 
 // pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
-import { stat } from "fs/promises";
-import path2 from "path";
 import { Logger as Logger3 } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/sshTunnel.ts
@@ -237,6 +334,8 @@ class IncrementalBuilderHost {
   app;
   ready = false;
   #onMessage;
+  #stdio;
+  #onOutput;
   #proc = null;
   #status = "stopped";
   #restartAttempts = 0;
@@ -247,11 +346,13 @@ class IncrementalBuilderHost {
   #manualStop = false;
   #inFlight = new Map;
   #startOptions = {};
-  constructor({ app, entry, env, onMessage }) {
+  constructor({ app, entry, env, stdio = "inherit", onMessage, onOutput }) {
     this.app = app;
     this.entry = entry;
     this.env = env;
+    this.#stdio = stdio;
     this.#onMessage = onMessage;
+    this.#onOutput = onOutput ?? null;
   }
   get status() {
     return this.#status;
@@ -277,7 +378,7 @@ class IncrementalBuilderHost {
     proc = Bun.spawn(["bun", this.entry], {
       cwd: this.app.cwdPath,
       env: { ...this.env, AKAN_WATCH: "1", ...afterRecycle ? { AKAN_BUILDER_ANNOUNCE_BOOT: "1" } : {} },
-      stdio: ["ignore", "inherit", "inherit"],
+      stdio: ["ignore", this.#stdio, this.#stdio],
       ipc: (msg) => {
         if (this.#proc !== proc)
           return;
@@ -325,8 +426,24 @@ class IncrementalBuilderHost {
       }
     });
     this.#proc = proc;
+    if (this.#stdio === "pipe" && this.#onOutput) {
+      this.#drain(proc.stdout, "stdout");
+      this.#drain(proc.stderr, "stderr");
+    }
     this.logger.verbose(`builder spawned pid=${proc.pid} entry=${this.entry}${isRestart ? " restart=1" : ""}`);
   }
+  async#drain(stream, kind) {
+    if (!stream)
+      return;
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        if (text)
+          this.#onOutput?.(kind, text);
+      }
+    } catch {}
+  }
   #scheduleRestart() {
     if (this.#manualStop || this.#restartTimer)
       return;
@@ -350,7 +467,7 @@ class IncrementalBuilderHost {
       return false;
     this.#recycleRequested = true;
     this.#status = "recycling";
-    this.logger.info(`recycling builder pid=${proc.pid} (${reason})`);
+    this.logger.debug(`recycling builder pid=${proc.pid} (${reason})`);
     this.#recycleTimer = setTimeout(() => {
       this.#recycleTimer = null;
       if (this.#proc !== proc)
@@ -422,7 +539,10 @@ class IncrementalBuilderHost {
     this.ready = false;
     this.#status = "stopped";
   }
-  static async create(app, env, onMessage) {
+  static async create(app, env, onMessage, {
+    stdio = "inherit",
+    onOutput
+  } = {}) {
     const candidates = [
       path.join(app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
       path.join(app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts"),
@@ -431,7 +551,7 @@ class IncrementalBuilderHost {
     ];
     for (const c of candidates)
       if (await Bun.file(c).exists())
-        return new IncrementalBuilderHost({ app, entry: c, env, onMessage });
+        return new IncrementalBuilderHost({ app, entry: c, env, stdio, onMessage, onOutput });
     throw new Error(`[cli] frontend builder entry not found; looked in: ${candidates.join(", ")}`);
   }
 }
@@ -470,38 +590,23 @@ class BuilderRequestRouter {
   }
 }
 
-// pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
-var backendMsgTypeSet = new Set(["build-route", "build-csr"]);
-var BACKEND_RESTART_DEBOUNCE_MS = 120;
-var BACKEND_GRACEFUL_TIMEOUT_MS = 8000;
-var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
-var BACKEND_RECOVERY_MAX_DELAY_MS = 30000;
+// 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 BACKEND_STDERR_TAIL_LIMIT = 40;
-var BUILDER_READY_TIMEOUT_MS = 150000;
-var BUILDER_START_MAX_ATTEMPTS = 3;
 var HELD_BUILDER_REQUEST_LIMIT = 64;
-var BUILDER_RSS_RECYCLE_QUIET_MS = 750;
 var BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS = 30000;
 var BUILDER_TIGHT_RSS_REPORT_LIMIT = 2;
-var BUILDER_RSS_SETTLE_MS = 20000;
-var PS_RSS_TIMEOUT_MS = 2000;
 var BUILDER_RSS_HARD_MULTIPLE = 1.5;
 var DEV_IDLE_SUSPEND_MS = 300000;
 var DEV_IDLE_MIN_UPTIME_MS = 30000;
-var BUILDER_RECOVERY_BASE_DELAY_MS = 2000;
-var BUILDER_RECOVERY_MAX_DELAY_MS = 60000;
 var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
-var NON_SOURCE_EXT_RE = /\.(css|scss|sass|less|json|svg|png|jpe?g|webp|gif|avif|ico|woff2?|ttf|otf|mp3|mp4|wav|html)$/i;
 var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
 var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
 var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
-var GRAPH_IMPORT_KINDS = new Set([
-  "import-statement",
-  "require-call",
-  "require-resolve",
-  "dynamic-import"
-]);
 var shouldRestartBackendByDevPlan = (message) => {
   if (!message.devPlan)
     return null;
@@ -515,6 +620,15 @@ var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includ
 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) => {
@@ -682,6 +796,15 @@ var mergeInvalidateMessages = (current, next) => {
 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",
+  "require-call",
+  "require-resolve",
+  "dynamic-import"
+]);
+
 class BackendImportGraph {
   #app;
   #logger;
@@ -704,7 +827,7 @@ class BackendImportGraph {
     return this.#lastRefreshSucceeded;
   }
   has(file) {
-    return this.#files.has(path2.resolve(file));
+    return this.#files.has(path3.resolve(file));
   }
   async fingerprint() {
     const stamps = await Promise.all([...this.#files].map(async (file) => {
@@ -732,9 +855,9 @@ class BackendImportGraph {
     const roots = await this.#entrypoints();
     const files = new Set;
     const queue = [...roots];
-    const workspaceRoot = path2.resolve(this.#app.workspace.workspaceRoot);
+    const workspaceRoot = path3.resolve(this.#app.workspace.workspaceRoot);
     while (queue.length > 0) {
-      const current = path2.resolve(queue.pop());
+      const current = path3.resolve(queue.pop());
       if (files.has(current))
         continue;
       if (!this.#isWorkspaceSource(current, workspaceRoot))
@@ -743,7 +866,7 @@ class BackendImportGraph {
       if (!imports)
         continue;
       files.add(current);
-      const importerDir = path2.dirname(current);
+      const importerDir = path3.dirname(current);
       for (const imp of imports) {
         if (!GRAPH_IMPORT_KINDS.has(imp.kind) || !imp.path || NON_SOURCE_EXT_RE.test(imp.path))
           continue;
@@ -774,7 +897,7 @@ class BackendImportGraph {
     const roots = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
     const existing = [];
     for (const root of roots) {
-      const abs = path2.resolve(root);
+      const abs = path3.resolve(root);
       if (await Bun.file(abs).exists())
         existing.push(abs);
     }
@@ -783,25 +906,25 @@ class BackendImportGraph {
   #resolve(specifier, importerDir) {
     try {
       const resolved = Bun.resolveSync(specifier, importerDir);
-      if (!path2.isAbsolute(resolved))
+      if (!path3.isAbsolute(resolved))
         return null;
-      if (!SOURCE_EXTS.has(path2.extname(resolved).toLowerCase()))
+      if (!SOURCE_EXTS.has(path3.extname(resolved).toLowerCase()))
         return null;
-      return path2.resolve(resolved);
+      return path3.resolve(resolved);
     } catch {
       return null;
     }
   }
   #isWorkspaceSource(file, workspaceRoot) {
-    const rel = path2.relative(workspaceRoot, file);
-    if (rel.startsWith("..") || path2.isAbsolute(rel))
+    const rel = path3.relative(workspaceRoot, file);
+    if (rel.startsWith("..") || path3.isAbsolute(rel))
       return false;
-    if (rel.includes(`${path2.sep}node_modules${path2.sep}`) || rel.includes(`${path2.sep}.akan${path2.sep}`))
+    if (rel.includes(`${path3.sep}node_modules${path3.sep}`) || rel.includes(`${path3.sep}.akan${path3.sep}`))
       return false;
-    return SOURCE_EXTS.has(path2.extname(file).toLowerCase());
+    return SOURCE_EXTS.has(path3.extname(file).toLowerCase());
   }
   #scanImports(file, source) {
-    const ext = path2.extname(file).toLowerCase();
+    const ext = path3.extname(file).toLowerCase();
     if (ext === ".tsx")
       return this.#tsxTranspiler.scanImports(source);
     if (ext === ".jsx")
@@ -812,11 +935,28 @@ class BackendImportGraph {
   }
 }
 
+// pkgs/@akanjs/devkit/akanApp/akanApp.host.ts
+var backendMsgTypeSet = new Set(["build-route", "build-csr"]);
+var BACKEND_RESTART_DEBOUNCE_MS = 120;
+var BACKEND_GRACEFUL_TIMEOUT_MS = 8000;
+var BACKEND_RECOVERY_BASE_DELAY_MS = 1000;
+var BACKEND_RECOVERY_MAX_DELAY_MS = 30000;
+var BACKEND_STDERR_TAIL_LIMIT = 40;
+var BUILDER_READY_TIMEOUT_MS = 150000;
+var BUILDER_START_MAX_ATTEMPTS = 3;
+var BUILDER_RSS_RECYCLE_QUIET_MS = 750;
+var BUILDER_RSS_SETTLE_MS = 20000;
+var PS_RSS_TIMEOUT_MS = 2000;
+var BUILDER_RECOVERY_BASE_DELAY_MS = 2000;
+var BUILDER_RECOVERY_MAX_DELAY_MS = 60000;
+
 class AkanAppHost {
   app;
   logger = new Logger3("AkanAppHost");
-  withInk;
+  stdio;
   env;
+  #onDevEvent;
+  #lastDevState = null;
   #backend = null;
   #builder = null;
   #backendReady = false;
@@ -855,12 +995,23 @@ class AkanAppHost {
   #builderGapStamp = null;
   #pendingBuilderMessages = [];
   #builderRequests = new BuilderRequestRouter;
-  constructor(app, { env, withInk = false }) {
+  constructor(app, {
+    env,
+    stdio = "inherit",
+    onDevEvent
+  }) {
     this.app = app;
     this.env = env;
-    this.withInk = withInk;
+    this.stdio = stdio;
+    this.#onDevEvent = onDevEvent ?? null;
     this.#backendGraph = new BackendImportGraph(app, this.logger);
   }
+  #emitDevEvent(state, detail) {
+    if (!this.#onDevEvent || state === this.#lastDevState)
+      return;
+    this.#lastDevState = state;
+    this.#onDevEvent({ app: this.app.name, state, ...detail ? { detail } : {} });
+  }
   async start() {
     if (this.#backend)
       await this.#stopBackend();
@@ -907,6 +1058,7 @@ class AkanAppHost {
   }
   #startBackend(startStatus = null) {
     this.#builderRequests.startGeneration();
+    this.#discardPendingBuilderMessages("the backend restarted while the builder was away");
     this.#backendStartStatus = startStatus;
     this.#backendGaveUp = false;
     this.#setBackendLifecycleState("starting");
@@ -914,7 +1066,7 @@ class AkanAppHost {
     this.#backendStderrTail = [];
     const backend = Bun.spawn(["bun", `apps/${this.app.name}/main.ts`], {
       cwd: this.app.workspace.workspaceRoot,
-      stdio: this.withInk ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
+      stdio: this.stdio === "pipe" ? ["ignore", "pipe", "pipe"] : ["inherit", "inherit", "inherit"],
       env: this.env,
       ipc: (msg) => {
         if (!msg || typeof msg !== "object")
@@ -955,7 +1107,7 @@ class AkanAppHost {
     });
     this.#backend = backend;
     this.logger.verbose(`backend spawned pid=${backend.pid}`);
-    if (this.withInk) {
+    if (this.stdio === "pipe") {
       this.#forwardBackendStream(backend.stderr, "stderr");
       this.#forwardBackendStream(backend.stdout, "stdout");
     }
@@ -976,14 +1128,13 @@ class AkanAppHost {
     try {
       for await (const chunk of stream) {
         const text = decoder.decode(chunk, { stream: true });
-        if (!text.trim())
+        if (!text)
           continue;
         if (kind === "stderr") {
           this.#recordBackendStderr(text);
-          this.logger.warn(`[backend] ${text.trimEnd()}`);
-        } else {
-          this.logger.verbose(`[backend] ${text.trimEnd()}`);
-        }
+          process.stderr.write(text);
+        } else
+          process.stdout.write(text);
       }
     } catch {}
   }
@@ -1030,6 +1181,7 @@ class AkanAppHost {
     const prev = this.#backendLifecycleState;
     this.#backendLifecycleState = next;
     this.logger.verbose(`[backend-lifecycle] ${prev} -> ${next}${detail ? ` ${detail}` : ""}`);
+    this.#emitDevEvent(devHostStateOf(next, this.#backendGaveUp), detail);
   }
   #sendToBackend(message) {
     if (!this.#backend || !this.#backendReady) {
@@ -1359,6 +1511,7 @@ ${this.#backendStderrTail.join(`
       return;
     }
     this.#suspended = true;
+    this.#emitDevEvent("suspended", `idle ${Math.round(idleMs / 1000)}s`);
     this.#stopBuilder();
     this.#openBuilderGap("idle suspend");
     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`);
@@ -1423,6 +1576,7 @@ ${this.#backendStderrTail.join(`
       this.#wokeAtMono = performance.now();
       this.#flushPendingBuilderMessages();
       this.#armIdleSuspend();
+      this.#emitDevEvent(devHostStateOf(this.#backendLifecycleState, this.#backendGaveUp));
     }
   }
   async#applyIdleWake(batch) {
@@ -1498,6 +1652,12 @@ ${this.#backendStderrTail.join(`
     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)
+      return;
+    this.logger.verbose(`[builder] dropped ${held.length} held builder request(s): ${reason}`);
+  }
   #failPendingBuilderMessages(reason) {
     const held = this.#pendingBuilderMessages.splice(0);
     if (held.length === 0)
@@ -1753,6 +1913,9 @@ ${this.#backendStderrTail.join(`
     for (let attempt = 1;attempt <= BUILDER_START_MAX_ATTEMPTS; attempt++) {
       this.#builder = await IncrementalBuilderHost.create(this.app, this.env, (msg) => {
         this.#enqueueBuilderMessage(msg);
+      }, {
+        stdio: this.stdio,
+        onOutput: (kind, text) => void (kind === "stderr" ? process.stderr : process.stdout).write(text)
       });
       try {
         await this.#waitForBuilderReady(attempt, { announceBootState });
@@ -1858,20 +2021,20 @@ ${this.#backendStderrTail.join(`
   }
 }
 // pkgs/@akanjs/devkit/applicationTestPreload.ts
-import path3 from "path";
+import path4 from "path";
 var SIGNAL_TEST_PRELOAD_PATH = "test/signalTest.preload.ts";
 async function resolveSignalTestPreloadPath(target) {
   const candidates = [];
   const addResolvedPackageCandidate = (basePath) => {
     try {
-      candidates.push(path3.join(path3.dirname(Bun.resolveSync("akanjs/package.json", basePath)), SIGNAL_TEST_PRELOAD_PATH));
+      candidates.push(path4.join(path4.dirname(Bun.resolveSync("akanjs/package.json", basePath)), SIGNAL_TEST_PRELOAD_PATH));
     } catch {}
   };
   addResolvedPackageCandidate(target.cwdPath);
   addResolvedPackageCandidate(process.cwd());
-  addResolvedPackageCandidate(path3.dirname(Bun.main));
+  addResolvedPackageCandidate(path4.dirname(Bun.main));
   addResolvedPackageCandidate(import.meta.dir);
-  candidates.push(path3.join(target.cwdPath, "../../node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(target.cwdPath, "../../pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(process.cwd(), "node_modules/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(process.cwd(), "pkgs/akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.join(path3.dirname(Bun.main), "../../akanjs", SIGNAL_TEST_PRELOAD_PATH), path3.resolve(import.meta.dir, "../../akanjs", SIGNAL_TEST_PRELOAD_PATH));
+  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) {
     if (await Bun.file(candidate).exists())
@@ -1886,22 +2049,10 @@ ${uniqueCandidates.map((candidate) => `  - ${candidate}`).join(`
 // pkgs/@akanjs/cli/application/application.runner.ts
 import { Logger as Logger4 } from "akanjs/common";
 import ora from "ora";
-
-// pkgs/@akanjs/cli/openBrowser.ts
-import { spawn } from "child_process";
-function openBrowser(url) {
-  const command = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? ["cmd", "/c", "start", "", url] : ["xdg-open", url];
-  const child = spawn(command[0], command.slice(1), { detached: true, stdio: "ignore" });
-  child.on("error", () => {});
-  child.unref();
-  return Promise.resolve();
-}
-
-// pkgs/@akanjs/cli/application/application.runner.ts
-var loadBuildRunner = async () => (await import("./applicationBuildRunner-6m8n71w4.js")).ApplicationBuildRunner;
-var loadReleasePackager = async () => (await import("./applicationReleasePackager-gg8ccbeh.js")).ApplicationReleasePackager;
-var loadCapacitorApp = async () => (await import("./capacitorApp-mr81qdxq.js")).CapacitorApp;
-var loadAbstractCompactor = async () => (await import("./abstractCompactor-e5yq60qz.js")).AbstractCompactor;
+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-mjh5ppsq.js")).AbstractCompactor;
 var loadPrompts = async () => await import("@inquirer/prompts");
 
 class ApplicationRunner extends runner("application") {
@@ -1914,8 +2065,11 @@ class ApplicationRunner extends runner("application") {
     });
     return AppExecutor.from(workspace, appName);
   }
+  async planSlice(app) {
+    return await new SlicePlanner(app).plan();
+  }
   async removeApplication(app) {
-    await app.workspace.exec(`rm -rf apps/${app.name}`);
+    await app.workspace.removeDir(`apps/${app.name}`);
   }
   async getConfig(app) {
     return await app.getConfig();
@@ -1945,10 +2099,69 @@ class ApplicationRunner extends runner("application") {
       stdio: "inherit"
     });
   }
+  #runtimeDirOf(app, override) {
+    return path5.resolve(override ?? process.env.AKAN_RUNTIME_DIR ?? path5.join(app.workspace.workspaceRoot, "local", "apps", app.name, "runtime"));
+  }
+  async runLogs(app, options) {
+    const { LogControlUnavailableError, LogTailClient } = await import("akanjs/server/logging/logTailClient");
+    const { LogQueryMatcher } = await import("akanjs/server/logging/logQuery");
+    const runtimeDir = this.#runtimeDirOf(app, options.runtimeDir);
+    const socketPath = LogTailClient.socketPath(runtimeDir);
+    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));
+    const note = (text) => process.stderr.write(`[akan logs] ${text}
+`);
+    let finish = null;
+    const closed = new Promise((resolve) => {
+      finish = resolve;
+    });
+    let client;
+    try {
+      client = await LogTailClient.connect(socketPath, {
+        onRecord: (entry) => print(entry.record),
+        onEvent: (response) => {
+          if (response.type === "dropped")
+            note(`${response.count} records dropped (reader too slow)`);
+        },
+        onClose: () => finish?.()
+      });
+    } catch (error) {
+      if (error instanceof LogControlUnavailableError)
+        throw new Error(`${app.name} is not running (no ${path5.basename(socketPath)} in ${runtimeDir}). Start it with \`akan start ${app.name}\`, or pass --runtime-dir for a built app.`);
+      throw error;
+    }
+    const sinceMs = since ? LogQueryMatcher.parseSince(since) : undefined;
+    const noteCoverage = (coverage) => {
+      if (sinceMs !== undefined && coverage.from !== null && sinceMs < coverage.from)
+        note(`${LogTailClient.describeCoverage(coverage)}; older records are not retained`);
+    };
+    if (endpoint)
+      note("requests served by the primitive query fast path carry no endpoint and are not shown");
+    if (options.follow === false) {
+      const { entries, coverage } = await client.history({
+        ...query,
+        ...options.replay ? { limit: options.replay } : {}
+      });
+      for (const entry of entries)
+        print(entry.record);
+      noteCoverage(coverage);
+      client.close();
+      return;
+    }
+    const subscribed = await client.subscribe(query, { replay: options.replay });
+    noteCoverage(subscribed.coverage);
+    const stop = () => client.close();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    await closed;
+  }
   async runConsole(app) {
     const serverPath = `${app.cwdPath}/server.ts`;
     if (!await app.exists("server.ts"))
       throw new Error(`Server file not found: apps/${app.name}/server.ts`);
+    const runtimeDir = this.#runtimeDirOf(app);
     const code = `
 const serverModule = await import(${JSON.stringify(serverPath)});
 const { assertAkanConsoleAllowed, startAkanConsole } = await import("akanjs/server");
@@ -1958,6 +2171,7 @@ assertAkanConsoleAllowed(server.env);
 await server.start({ listen: false, web: false });
 try {
   await startAkanConsole(server, {
+    runtimeDir: ${JSON.stringify(runtimeDir)},
     globals: {
       srv: serverModule.srv,
       sig: serverModule.sig,
@@ -2005,9 +2219,14 @@ try {
   } = {}) {
     return new (await loadBuildRunner())(app, { fast, reporter }).build({ spinner });
   }
-  async start(app, { open = false, onStart, withInk = false } = {}) {
+  async start(app, {
+    open = false,
+    onStart,
+    onDevEvent,
+    stdio = "inherit"
+  } = {}) {
     const { env } = await app.prepareCommand("start");
-    const appHost = await new AkanAppHost(app, { env, withInk }).start();
+    const appHost = await new AkanAppHost(app, { env, stdio, onDevEvent }).start();
     onStart?.();
     if (open)
       setTimeout(() => openBrowser(`http://localhost:${env.AKAN_PUBLIC_CLIENT_PORT ?? env.PORT ?? "8282"}`), 3000);
@@ -2239,6 +2458,602 @@ ${detail}`
   }
 }
 
+// pkgs/@akanjs/cli/application/devPortReclaimer.ts
+class DevPortReclaimer {
+  static lsofTimeoutMs = 3000;
+  static releaseTimeoutMs = 8000;
+  static maxAncestorDepth = 8;
+  static #releasePollMs = 100;
+  static wsPortOffset = 1e4;
+  static portsFor(ports) {
+    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");
+  }
+  async reclaim(ports) {
+    const killed = [];
+    const foreign = [];
+    const seen = new Set;
+    for (const port of DevPortReclaimer.portsFor(ports)) {
+      for (const holder of await this.holdersOf(port)) {
+        if (seen.has(holder.pid))
+          continue;
+        seen.add(holder.pid);
+        if (!holder.akan) {
+          foreign.push(holder);
+          continue;
+        }
+        if (await this.#terminate(holder.pid))
+          killed.push(holder);
+        else
+          foreign.push(holder);
+      }
+    }
+    return { killed, foreign };
+  }
+  async holdersOf(port) {
+    const holders = [];
+    for (const listenerPid of await this.#pidsOn(port)) {
+      if (listenerPid === process.pid || listenerPid === process.ppid)
+        continue;
+      const command = await this.#commandOf(listenerPid);
+      if (!command)
+        continue;
+      if (!DevPortReclaimer.isAkanCommand(command)) {
+        holders.push({ pid: listenerPid, command, port, listenerPid, akan: false });
+        continue;
+      }
+      const root = await this.#akanRootOf(listenerPid, command);
+      holders.push({ pid: root.pid, command: root.command, port, listenerPid, akan: true });
+    }
+    return holders;
+  }
+  async#akanRootOf(pid, command) {
+    let root = { pid, command };
+    for (let depth = 0;depth < DevPortReclaimer.maxAncestorDepth; depth += 1) {
+      const parentPid = await this.#ppidOf(root.pid);
+      if (parentPid === null || parentPid <= 1 || parentPid === process.pid || parentPid === process.ppid)
+        break;
+      const parentCommand = await this.#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.#signal(pid, "SIGTERM"))
+      return !this.#alive(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);
+  }
+  #signal(pid, signal) {
+    try {
+      process.kill(pid, signal);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  #alive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      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 chalk from "chalk";
+var appColors = ["cyan", "magenta", "yellow", "green", "blue", "red"];
+
+class DevStreamView {
+  #logger = new Logger5("akan start");
+  #partial = new Map;
+  #lastState = new Map;
+  #color = new Map;
+  #width = 0;
+  constructor(appNames) {
+    this.#width = appNames.reduce((max, name) => Math.max(max, name.length), 0);
+    appNames.forEach((name, idx) => {
+      this.#color.set(name, appColors[idx % appColors.length] ?? "cyan");
+    });
+  }
+  onOutput = (app, kind, text) => {
+    const key = `${app}:${kind}`;
+    const pending = `${this.#partial.get(key) ?? ""}${text}`;
+    const lines = pending.split(`
+`);
+    this.#partial.set(key, lines.pop() ?? "");
+    if (lines.length === 0)
+      return;
+    const prefixed = lines.map((line) => `${this.#prefix(app)}${line}`).join(`
+`);
+    (kind === "stderr" ? process.stderr : process.stdout).write(`${prefixed}
+`);
+  };
+  onStatus = (statuses) => {
+    for (const status of statuses) {
+      if (this.#lastState.get(status.name) === status.state)
+        continue;
+      this.#lastState.set(status.name, status.state);
+      const detail = status.detail ? ` (${status.detail})` : "";
+      const where = status.state === "ready" ? ` \u2014 ${status.url}` : "";
+      const line = `${status.name} ${status.state}${detail}${where}`;
+      if (status.state === "failed")
+        this.#logger.error(line);
+      else if (status.state === "stopped")
+        this.#logger.warn(line);
+      else
+        this.#logger.info(line);
+    }
+  };
+  onNote = (text, level) => {
+    if (level === "warn")
+      this.#logger.warn(text);
+    else
+      this.#logger.info(text);
+  };
+  waitForExit = () => new Promise(() => {
+    return;
+  });
+  close = () => {
+    for (const [key, remainder] of this.#partial) {
+      if (!remainder)
+        continue;
+      const app = key.slice(0, key.lastIndexOf(":"));
+      process.stdout.write(`${this.#prefix(app)}${remainder}
+`);
+    }
+    this.#partial.clear();
+  };
+  #prefix(app) {
+    const color = this.#color.get(app) ?? "cyan";
+    return `${chalk[color](app.padEnd(this.#width))} ${chalk.dim("\u2502")} `;
+  }
+}
+
+// pkgs/@akanjs/cli/application/devBootConcurrency.ts
+import os from "os";
+import { MemoryLimit as MemoryLimit2 } from "akanjs/server/memoryLimit";
+
+class DevBootConcurrency {
+  static perAppBytes = 900 * 1024 * 1024;
+  static memoryShare = 0.5;
+  static coresPerApp = 4;
+  static budget() {
+    const hostBytes = os.totalmem();
+    const declaredBytes = MemoryLimit2.parseBytesEnv("AKAN_MEMORY_LIMIT") ?? MemoryLimit2.readCgroupBytes();
+    return { memoryBytes: Math.min(hostBytes, declaredBytes ?? hostBytes), cores: os.availableParallelism() };
+  }
+  static resolve(appCount, requested, budget = DevBootConcurrency.budget()) {
+    const apps = Math.max(1, Math.trunc(appCount));
+    if (requested !== null && Number.isFinite(requested)) {
+      const asked = Math.max(1, Math.trunc(requested));
+      return { concurrency: Math.min(apps, asked), reason: `--concurrency ${asked}` };
+    }
+    const byMemory = Math.floor(budget.memoryBytes * DevBootConcurrency.memoryShare / DevBootConcurrency.perAppBytes);
+    const byCores = Math.floor(budget.cores / DevBootConcurrency.coresPerApp);
+    return {
+      concurrency: Math.max(1, Math.min(apps, byMemory, byCores)),
+      reason: `${budget.cores} cores, ${DevBootConcurrency.#formatBytes(budget.memoryBytes)} memory`
+    };
+  }
+  static describe(appCount, plan) {
+    if (plan.concurrency >= appCount)
+      return `booting all ${appCount} apps at once (${plan.reason})`;
+    return `booting ${plan.concurrency} of ${appCount} apps at a time (${plan.reason}) \u2014 --concurrency raises it`;
+  }
+  static #formatBytes(bytes) {
+    const gigabytes = bytes / 1024 ** 3;
+    return gigabytes >= 10 ? `${Math.round(gigabytes)}GB` : `${gigabytes.toFixed(1)}GB`;
+  }
+}
+
+// pkgs/@akanjs/cli/application/devSessionLog.ts
+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";
+  static flushMs = 200;
+  static bufferBytes = 64 * 1024;
+  #workspaceRoot;
+  #appNames;
+  #now;
+  #writers = new Map;
+  #partial = new Map;
+  #lastState = new Map;
+  #flushTimer = null;
+  constructor({ workspaceRoot, apps, now = () => new Date }) {
+    this.#workspaceRoot = workspaceRoot;
+    this.#appNames = [...apps];
+    this.#now = now;
+  }
+  get appNames() {
+    return [...this.#appNames];
+  }
+  pathOf(app) {
+    return path6.join(this.#runtimeDirOf(app), DevSessionLog.fileName);
+  }
+  previousPathOf(app) {
+    return path6.join(this.#runtimeDirOf(app), DevSessionLog.previousFileName);
+  }
+  relativePathOf(app) {
+    return path6.relative(this.#workspaceRoot, this.pathOf(app));
+  }
+  async open() {
+    const stamp = dayjs(this.#now()).format("YYYY-MM-DD HH:mm:ss");
+    for (const app of this.#appNames) {
+      const file = this.pathOf(app);
+      await mkdir(path6.dirname(file), { recursive: true });
+      await rename(file, this.previousPathOf(app)).catch(() => {
+        return;
+      });
+      this.#writers.set(app, Bun.file(file).writer({ highWaterMark: DevSessionLog.bufferBytes }));
+      this.#writeLine(app, `\u2500\u2500 akan start \xB7 ${app} \xB7 ${stamp} \u2500\u2500`);
+    }
+  }
+  write(app, kind, chunk) {
+    const key = `${app}:${kind}`;
+    const parts = `${this.#partial.get(key) ?? ""}${chunk}`.split(`
+`);
+    this.#partial.set(key, parts.pop() ?? "");
+    for (const line of parts)
+      this.#writeLine(app, stripAnsi(line));
+  }
+  note(text) {
+    for (const app of this.#appNames)
+      this.#writeLine(app, `[akan] ${text}`);
+  }
+  status(statuses) {
+    for (const status of statuses) {
+      if (this.#lastState.get(status.name) === status.state)
+        continue;
+      this.#lastState.set(status.name, status.state);
+      const detail = status.detail ? ` (${status.detail})` : "";
+      const where = status.state === "ready" ? ` \u2014 ${status.url}` : "";
+      this.#writeLine(status.name, `[akan] ${status.name} ${status.state}${detail}${where}`);
+    }
+  }
+  async close() {
+    for (const [key, remainder] of this.#partial) {
+      if (!remainder)
+        continue;
+      this.#writeLine(key.slice(0, key.lastIndexOf(":")), stripAnsi(remainder));
+    }
+    this.#partial.clear();
+    if (this.#flushTimer)
+      clearTimeout(this.#flushTimer);
+    this.#flushTimer = null;
+    await Promise.all([...this.#writers.values()].map(async (writer) => await writer.end()));
+    this.#writers.clear();
+  }
+  #runtimeDirOf(app) {
+    return path6.join(this.#workspaceRoot, "local", "apps", app, "runtime");
+  }
+  #writeLine(app, text) {
+    const writer = this.#writers.get(app);
+    if (!writer)
+      return;
+    writer.write(`${text}
+`);
+    this.#scheduleFlush();
+  }
+  #scheduleFlush() {
+    if (this.#flushTimer)
+      return;
+    this.#flushTimer = setTimeout(() => {
+      this.#flushTimer = null;
+      for (const writer of this.#writers.values())
+        writer.flush();
+    }, DevSessionLog.flushMs);
+  }
+}
+
+// pkgs/@akanjs/cli/application/devSupervisor.ts
+class DevSupervisor {
+  static supervisedEnvKey = "AKAN_DEV_SUPERVISED";
+  static childHooks() {
+    if (process.env[DevSupervisor.supervisedEnvKey] !== "1" || !process.send)
+      return {};
+    const send = process.send.bind(process);
+    return {
+      stdio: "pipe",
+      onDevEvent: (event) => {
+        try {
+          send(event);
+        } catch {}
+      }
+    };
+  }
+  static readyTimeoutMs = 180000;
+  static shutdownGraceMs = 12000;
+  #options;
+  #children = new Map;
+  #sessionLog;
+  #view = null;
+  #stopping = false;
+  constructor(options) {
+    this.#options = options;
+    this.#sessionLog = new DevSessionLog({
+      workspaceRoot: options.apps[0]?.workspace.workspaceRoot ?? process.cwd(),
+      apps: options.apps.map((app) => app.name)
+    });
+  }
+  get statuses() {
+    return [...this.#children.values()].map((child) => child.status);
+  }
+  get sessionLog() {
+    return this.#sessionLog;
+  }
+  async run(view) {
+    this.#view = view;
+    await this.#sessionLog.open();
+    const ports = await this.#assignPorts();
+    for (const app of this.#options.apps)
+      this.#children.set(app.name, this.#makeChild(app, ports.get(app.name) ?? 0));
+    this.#publishStatus();
+    const logPaths = this.#sessionLog.appNames.map((name) => this.#sessionLog.relativePathOf(name));
+    this.#note(`session log: ${logPaths.join(" \xB7 ")}`, "info");
+    const stopped = this.#installSignalHandlers();
+    this.#bootInOrder();
+    await Promise.race([view.waitForExit(), stopped]);
+    await this.stop();
+    view.close?.();
+    await this.#sessionLog.close();
+  }
+  async#assignPorts() {
+    const taken = new Set;
+    const ports = new Map;
+    for (const app of this.#options.apps) {
+      let port = await app.getDevPort();
+      while (taken.has(port))
+        port += 1;
+      taken.add(port);
+      ports.set(app.name, port);
+    }
+    return ports;
+  }
+  #makeChild(app, port) {
+    let markReady;
+    const ready = new Promise((resolve) => {
+      markReady = resolve;
+    });
+    return {
+      status: {
+        app,
+        name: app.name,
+        port,
+        url: `http://localhost:${port}`,
+        state: "starting",
+        detail: "queued",
+        exitCode: null
+      },
+      proc: null,
+      ready,
+      markReady,
+      opened: false
+    };
+  }
+  async#bootInOrder() {
+    const queue = [...this.#children.values()];
+    const plan = DevBootConcurrency.resolve(queue.length, this.#options.concurrency ?? null);
+    const concurrency = plan.concurrency;
+    if (queue.length > 1)
+      this.#note(DevBootConcurrency.describe(queue.length, plan), "info");
+    const waves = [];
+    for (let idx = 0;idx < queue.length; idx += concurrency)
+      waves.push(queue.slice(idx, idx + concurrency));
+    for (const wave of waves) {
+      if (this.#stopping)
+        return;
+      for (const child of wave)
+        this.#spawnChild(child);
+      this.#publishStatus();
+      await Promise.all(wave.map(async (child) => await this.#waitForReady(child)));
+    }
+  }
+  async#waitForReady(child) {
+    let timer = null;
+    const expired = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("expired"), DevSupervisor.readyTimeoutMs);
+    });
+    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");
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  static childArgs(name, { write = true } = {}) {
+    return [
+      "start",
+      name,
+      "--plain",
+      "--dbup",
+      "false",
+      "--write",
+      String(write)
+    ];
+  }
+  #spawnChild(child) {
+    const { app, name, port } = child.status;
+    const args = DevSupervisor.childArgs(name, { write: this.#options.write ?? true });
+    const proc = Bun.spawn([process.execPath, Bun.main, ...args], {
+      cwd: app.workspace.workspaceRoot,
+      env: {
+        ...process.env,
+        [DevSupervisor.supervisedEnvKey]: "1",
+        AKAN_PUBLIC_APP_NAME: name,
+        AKAN_DEV_PORT: String(port)
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      ipc: (message) => {
+        if (!message || typeof message !== "object" || typeof message.state !== "string")
+          return;
+        this.#applyChildEvent(child, message);
+      },
+      serialization: "advanced",
+      onExit: (_proc, exitCode, signalCode) => {
+        child.proc = null;
+        child.status.exitCode = exitCode;
+        if (this.#stopping)
+          return;
+        child.status.state = "stopped";
+        child.status.detail = signalCode ? `killed by ${signalCode}` : `exited with ${exitCode}`;
+        child.markReady();
+        this.#publishStatus();
+      }
+    });
+    child.proc = proc;
+    child.status.state = "starting";
+    child.status.detail = `pid ${proc.pid}`;
+    this.#drain(proc.stdout, name, "stdout");
+    this.#drain(proc.stderr, name, "stderr");
+  }
+  #applyChildEvent(child, event) {
+    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();
+    this.#publishStatus();
+  }
+  async#drain(stream, name, kind) {
+    const decoder = new TextDecoder;
+    try {
+      for await (const chunk of stream) {
+        const text = decoder.decode(chunk, { stream: true });
+        if (!text)
+          continue;
+        this.#view?.onOutput(name, kind, text);
+        this.#sessionLog.write(name, kind, text);
+      }
+    } catch {}
+  }
+  #publishStatus() {
+    this.#view?.onStatus(this.statuses);
+    this.#sessionLog.status(this.statuses);
+  }
+  #note(text, level) {
+    this.#view?.onNote(text, level);
+    this.#sessionLog.note(text);
+  }
+  #installSignalHandlers() {
+    return new Promise((resolve) => {
+      let asked = false;
+      const onSignal = () => {
+        if (asked) {
+          this.#note("abandoning the wait; children may be left running", "warn");
+          process.exit(130);
+        }
+        asked = true;
+        resolve();
+      };
+      process.on("SIGINT", onSignal);
+      process.on("SIGTERM", onSignal);
+    });
+  }
+  async restart(name) {
+    const child = this.#children.get(name);
+    if (!child || this.#stopping)
+      return;
+    const running = child.proc;
+    if (running) {
+      running.kill("SIGTERM");
+      await running.exited;
+    }
+    child.status.state = "starting";
+    child.status.detail = "restarting";
+    child.status.exitCode = null;
+    this.#publishStatus();
+    this.#spawnChild(child);
+    this.#publishStatus();
+  }
+  async stop() {
+    if (this.#stopping)
+      return;
+    this.#stopping = true;
+    const running = [...this.#children.values()].filter((child) => Boolean(child.proc));
+    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);
+    }
+  }
+}
+
+// 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/application.script.ts
 class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
   static dbShutdownTimeoutMs = 20000;
@@ -2322,13 +3137,19 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     spinner.succeed(`Application created in apps/${app.name}`);
     await app.scanSync();
     if (start)
-      await this.start(app, { open: true });
+      await this.startOne(app, { open: true });
   }
   async removeApplication(app) {
     const spinner = app.spinning("Removing application...");
     await this.applicationRunner.removeApplication(app);
     spinner.succeed(`Application ${app.name} (apps/${app.name}) removed`);
   }
+  async planSlice(app, format = "text") {
+    const spinner = app.spinning("Planning distributable slice...");
+    const plan = await this.applicationRunner.planSlice(app);
+    spinner.succeed(`Slice planned (${plan.libs.length} libs, ${plan.warnings.length} warnings)`);
+    Logger6.rawLog(format === "json" ? JSON.stringify(plan, null, 2) : formatSlicePlan(plan));
+  }
   async sync(sys) {
     if (sys.type === "app")
       await sys.scanSync();
@@ -2338,13 +3159,13 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
   async compact(sys, { module = null, minLines, interactive = false } = {}) {
     const { scanned, reports } = await this.applicationRunner.compact(sys, { module, minLines, interactive });
     if (!reports.length) {
-      Logger5.rawLog(`No abstract file long enough to compact in ${sys.name} (${scanned} scanned)`);
+      Logger6.rawLog(`No abstract file long enough to compact in ${sys.name} (${scanned} scanned)`);
       return;
     }
     for (const report of reports)
-      Logger5.rawLog(`${report.status}: ${report.path} (${report.beforeLines} -> ${report.afterLines} lines)`);
+      Logger6.rawLog(`${report.status}: ${report.path} (${report.beforeLines} -> ${report.afterLines} lines)`);
     const compactedNum = reports.filter((report) => report.status === "compacted").length;
-    Logger5.rawLog(`Compacted ${compactedNum}/${reports.length} abstract files in ${sys.name}`);
+    Logger6.rawLog(`Compacted ${compactedNum}/${reports.length} abstract files in ${sys.name}`);
   }
   async script(app, filename) {
     const scriptFilename = filename ?? await this.applicationRunner.getScriptFilename(app);
@@ -2355,21 +3176,24 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     await app.scanSync();
     await this.applicationRunner.runConsole(app);
   }
+  async logs(app, options) {
+    await this.applicationRunner.runLogs(app, options);
+  }
   async build(app, { write = true, fast = false, quiet = false } = {}) {
     await app.scanSync({ write });
     if (!quiet)
-      Logger5.rawLog(`Creating an optimized production build for ${app.name}...`);
+      Logger6.rawLog(`Creating an optimized production build for ${app.name}...`);
     try {
       const result = await this.applicationRunner.build(app, {
         fast,
         spinner: !quiet
       });
-      Logger5.rawLog(`${app.name} built in dist/apps/${app.name}`);
+      Logger6.rawLog(`${app.name} built in dist/apps/${app.name}`);
       if (!quiet)
         ApplicationBuildReporter.printSummary(result);
     } catch (error) {
-      Logger5.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
-      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger6.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
+      Logger6.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
@@ -2381,15 +3205,15 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       spinner.succeed(`${app.name} typechecked`);
     } catch (error) {
       spinner.fail(`${app.name} typecheck failed`);
-      Logger5.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
+      Logger6.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
       throw error;
     }
   }
   async test(exec, { write = true } = {}) {
     if (exec instanceof LibExecutor) {
       await this.libraryScript.syncLibrary(exec);
-      const spinner2 = exec.spinning(`Preparing ${exec.name}...`);
-      spinner2.succeed(`${exec.name} prepared`);
+      const spinner = exec.spinning(`Preparing ${exec.name}...`);
+      spinner.succeed(`${exec.name} prepared`);
       await this.applicationRunner.test(exec);
       return;
     }
@@ -2406,12 +3230,20 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     }
     await this.applicationRunner.test(exec);
   }
-  async start(app, {
-    open = false,
-    dbup = true,
-    withInk = false,
-    write = true
-  } = {}) {
+  async start(apps, { open = false, dbup = true, write = true, plain = false, kill = false, concurrency = null } = {}) {
+    const first = apps[0];
+    if (!first)
+      throw new Error("No app selected to start");
+    const { mode, downgraded } = resolveDevUi(plain);
+    if (downgraded)
+      first.workspace.log("no sized terminal to draw on; printing prefixed lines instead");
+    if (kill)
+      await this.reclaimDevPorts(apps);
+    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 });
+  }
+  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";
@@ -2427,10 +3259,55 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
       onStart: () => {
         spinner.succeed(`${app.name} prepared, ready to start`);
       },
-      withInk
+      onDevEvent,
+      stdio
     });
     return akanAppHost;
   }
+  async reclaimDevPorts(apps) {
+    const workspace = apps[0]?.workspace;
+    if (!workspace)
+      return;
+    const ports = await Promise.all(apps.map(async (app) => await app.getDevPort()));
+    const { killed, foreign } = await new DevPortReclaimer().reclaim(ports);
+    for (const holder of killed)
+      workspace.log(`freed port ${holder.port} \u2014 killed pid ${holder.pid} (${holder.command})`);
+    for (const holder of foreign)
+      Logger6.rawLog(`port ${holder.port} is held by pid ${holder.pid} and was left alone: ${holder.command}`, undefined, "error");
+    if (killed.length === 0 && foreign.length === 0)
+      workspace.log("dev ports are free; nothing to kill");
+  }
+  async#startMany(apps, { open, dbup, write, mode, concurrency }) {
+    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-c08ccbat.js")).createDevTuiView(supervisor) : new DevStreamView(apps.map((app) => app.name));
+    await supervisor.run(view);
+    if (startedDatabase)
+      await this.#stopDatabase(workspace);
+  }
+  async#prepareSharedDatabase(apps) {
+    const workspace = apps[0]?.workspace;
+    if (!workspace)
+      return false;
+    const modes = new Set;
+    for (const app of apps) {
+      if (app.getEnv() !== "local")
+        continue;
+      const akanConfig = await app.getConfig();
+      const mode = process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single";
+      await this.syncDatabaseModeDependencies(app, akanConfig, mode);
+      if (mode !== "single")
+        modes.add(mode);
+    }
+    let started = false;
+    for (const mode of modes)
+      if (!await this.dbup(workspace, mode))
+        started = true;
+    return started;
+  }
   async buildIos(app, { write = true, target, env = "debug", regenerate = false } = {}) {
     await app.scanSync({ write });
     await this.applicationRunner.buildIos(app, { target, env, regenerate });
@@ -2528,7 +3405,7 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     let stopping = false;
     process.on("SIGINT", () => {
       if (stopping) {
-        Logger5.rawLog("Abandoning the local database teardown; containers are left running.", undefined, "warn");
+        Logger6.rawLog("Abandoning the local database teardown; containers are left running.", undefined, "error");
         process.exit(130);
       }
       stopping = true;
@@ -2536,25 +3413,22 @@ class ApplicationScript extends script("application", [ApplicationRunner, Librar
     });
   }
   async#stopDatabase(workspace) {
-    const timeout = new Promise((resolve) => setTimeout(() => resolve("timeout"), ApplicationScript.dbShutdownTimeoutMs));
-    const result = await Promise.race([this.dbdown(workspace).catch(() => {
-      return;
-    }), timeout]);
-    if (result !== "timeout")
-      return;
-    Logger5.rawLog(`Local database did not stop within ${ApplicationScript.dbShutdownTimeoutMs}ms; run \`akan dbdown\` once Docker responds.`, undefined, "warn");
-  }
-  async testSys(sys) {
-    if (sys.type === "app")
-      await this.testApplication(sys);
-    else
-      await this.libraryScript.testLibrary(sys);
-  }
-  async testApplication(app) {
-    const spinner = app.spinning("Testing application...");
-    await this.applicationRunner.test(app);
-    spinner.succeed(`Application ${app.name} (apps/${app.name}) test is successful`);
+    let timer = null;
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve("timeout"), ApplicationScript.dbShutdownTimeoutMs);
+    });
+    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);
+    }
   }
 }
 
-export { openBrowser, ApplicationScript };
+export { openBrowser, plainTextOf, HOST_SOURCE, DevLogBuffer, ApplicationScript };