@struktoai/mirage-dsh 0.0.7-alpha.2 → 0.0.7

package/dist/{chunk-QTBMLMKT.js → chunk-KUIV2Z3M.js}

@@ -1,147 +1,32 @@
 import {
-  TailBuffer,
-  tailCap
-} from "./chunk-2F2PJ7D7.js";
+  SpillSink,
+  ensureDirPath
+} from "./chunk-QH5H3VND.js";
+import {
+  StreamTail,
+  TailBuffer
+} from "./chunk-OZ2F4R6T.js";
 
 // src/shell.ts
 import { DSH_ENV_PREFIX, ShellExecutor } from "@deepseek-ai/dsh-shell";
 import {
-  Channel as Channel2,
+  Channel,
   JobConsole,
   KILLED_OUTCOME,
-  RAMConsoleStore,
   exitOutcome
 } from "@struktoai/mirage-core/shell/console/index";
 import { setCwd } from "@struktoai/mirage-core/workspace/session/shell_dirs";
 import { sessionView } from "@struktoai/mirage-core/workspace/session/state";
-
-// src/spill.ts
-import { Channel } from "@struktoai/mirage-core/shell/console/index";
-async function ensureDirPath(dirs, dir) {
-  let path = "";
-  for (const part of dir.split("/").filter((p) => p !== "")) {
-    path += `/${part}`;
-    if (await dirs.exists(path)) continue;
-    try {
-      await dirs.mkdir(path);
-    } catch (err) {
-      if (!await dirs.exists(path)) throw err;
-    }
-  }
-}
-function totalLength(parts) {
-  return parts.reduce((sum, p) => sum + p.byteLength, 0);
-}
-function concat(parts) {
-  const out = new Uint8Array(totalLength(parts));
-  let at = 0;
-  for (const p of parts) {
-    out.set(p, at);
-    at += p.byteLength;
-  }
-  return out;
-}
-var SpillSink = class {
-  stdoutPath;
-  stderrPath;
-  target;
-  dir;
-  base;
-  onFailure;
-  started = false;
-  failed = false;
-  stdoutParts = [];
-  stderrParts = [];
-  constructor(target, dir, base, onFailure = () => void 0) {
-    this.target = target;
-    this.dir = dir;
-    this.base = base;
-    this.onFailure = onFailure;
-  }
-  /** Buffer a chunk before spill starts, or append it to the file after. */
-  async ingest(channel, data) {
-    if (this.failed) return;
-    if (!this.started) {
-      if (channel === Channel.STDERR) this.stderrParts.push(data);
-      else this.stdoutParts.push(data);
-      return;
-    }
-    await this.appendFile(channel, data);
-  }
-  /** Flush the buffered streams to files; called once, on the first overrun. */
-  async begin() {
-    if (this.started || this.failed) return;
-    try {
-      await this.target.ensureDir(this.dir);
-      if (totalLength(this.stdoutParts) > 0) {
-        this.stdoutPath = `${this.dir}/${this.base}.stdout`;
-        await this.target.write(this.stdoutPath, concat(this.stdoutParts));
-      }
-      if (totalLength(this.stderrParts) > 0) {
-        this.stderrPath = `${this.dir}/${this.base}.stderr`;
-        await this.target.write(this.stderrPath, concat(this.stderrParts));
-      }
-      this.started = true;
-      this.stdoutParts = [];
-      this.stderrParts = [];
-    } catch (err) {
-      this.onFailure(err);
-      this.disable();
-    }
-  }
-  async appendFile(channel, data) {
-    try {
-      if (channel === Channel.STDERR) {
-        if (this.stderrPath === void 0) {
-          this.stderrPath = `${this.dir}/${this.base}.stderr`;
-          await this.target.write(this.stderrPath, data);
-        } else {
-          await this.target.append(this.stderrPath, data);
-        }
-      } else {
-        if (this.stdoutPath === void 0) {
-          this.stdoutPath = `${this.dir}/${this.base}.stdout`;
-          await this.target.write(this.stdoutPath, data);
-        } else {
-          await this.target.append(this.stdoutPath, data);
-        }
-      }
-    } catch (err) {
-      this.onFailure(err);
-      this.disable();
-    }
-  }
-  /**
-   * Give up on spilling and report no path.
-   *
-   * Called on a write failure, and by a reader that discovers it lost
-   * bytes before they ever reached here: a file missing the middle of
-   * the stream is worse than no file, because the path presents it as
-   * the whole one.
-   */
-  disable() {
-    this.failed = true;
-    this.stdoutPath = void 0;
-    this.stderrPath = void 0;
-    this.stdoutParts = [];
-    this.stderrParts = [];
-  }
-};
-
-// src/shell.ts
+import { refusalLine } from "@struktoai/mirage-core/workspace/tools/io_text";
+import { rstripSlash } from "@struktoai/mirage-core/utils/slash";
 var DEFAULT_TIMEOUT_MS = 12e4;
 var MAX_TIMEOUT_MS = 6e5;
 var DEFAULT_STDOUT_MAX_BYTES = 2e5;
 var DEFAULT_STDERR_MAX_BYTES = 64e3;
 var STDERR_MARKER = new TextEncoder().encode("\n--- stderr ---\n");
-var CONSOLE_RETENTION_DELTAS = 5;
 var spillCounter = 0;
 var SINK_PREFIX = "/dev";
 var DENIAL_SIGNATURES = ["read-only mount at ", ": Permission denied", ": Read-only file system"];
-function collect(text, maxBytes) {
-  const capped = tailCap(text, maxBytes);
-  return { text: capped.text, truncated: capped.truncated };
-}
 function executeOptions(spec, workdir, signal, sessionId, bound, fallbackWorkdir, sink) {
   const managed = spec.dshEnv ?? {};
   const env = bound ? { ...spec.env ?? {} } : { ...spec.env ?? {}, ...managed };
@@ -155,51 +40,102 @@ function executeOptions(spec, workdir, signal, sessionId, bound, fallbackWorkdir
     ...sink !== void 0 ? { sink } : {}
   };
 }
-var MirageShellProcess = class {
+function untilAborted(work, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    work.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", abort);
+    });
+  });
+}
+var ExecutionStore = class {
+  constructor(deliver) {
+    this.deliver = deliver;
+  }
+  deliver;
+  nextSeq = 0;
+  isClosed = false;
+  waiters = [];
+  get closed() {
+    return this.isClosed;
+  }
+  async append(channel, data) {
+    const chunk = { seq: this.nextSeq, ts: Date.now() / 1e3, channel, data };
+    this.nextSeq += 1;
+    await this.deliver(chunk);
+    return chunk;
+  }
+  readFrom() {
+    return Promise.resolve([[], this.nextSeq, false]);
+  }
+  wait() {
+    if (this.isClosed) return Promise.resolve();
+    return new Promise((resolve) => {
+      this.waiters.push(resolve);
+    });
+  }
+  close() {
+    this.isClosed = true;
+    for (const resolve of this.waiters.splice(0)) resolve();
+    return Promise.resolve();
+  }
+};
+var MirageShellExecution = class {
   status = "running";
   exitCode = null;
   signal = null;
   sandbox;
   done;
-  controller;
+  observed;
+  parts;
   console;
-  budget;
-  spill;
-  sandboxInfo;
-  consumed;
   pending;
+  stdoutTail;
+  stderrTail;
+  failure = null;
+  settledResult = null;
   lossy = false;
   inStderr = false;
   settled = false;
-  expectSeq = 0;
-  constructor(run, controller, console_, budget, spill, sandboxInfo) {
-    this.controller = controller;
-    this.console = console_;
-    this.budget = budget;
-    this.pending = new TailBuffer(budget);
-    this.spill = spill;
-    this.sandboxInfo = sandboxInfo;
-    this.consumed = this.consume();
-    this.done = run.then(
+  /**
+   * @param launch starts the command streaming into the console it is
+   *   handed; null when the deadline expired while it was being prepared.
+   * @param parts what the execution needs from its executor.
+   */
+  constructor(launch, parts) {
+    this.parts = parts;
+    this.console = new JobConsole(
+      new ExecutionStore(
+        (chunk) => chunk.channel === Channel.CONTROL ? Promise.resolve() : this.appendChunk(chunk)
+      )
+    );
+    this.pending = new TailBuffer(parts.budget);
+    this.stdoutTail = new StreamTail(parts.stdoutMaxBytes);
+    this.stderrTail = new StreamTail(parts.stderrMaxBytes);
+    this.observed = {
+      stdout: { readFrom: (from) => this.readStream(this.stdoutTail, from, "stdout") },
+      stderr: { readFrom: (from) => this.readStream(this.stderrTail, from, "stderr") }
+    };
+    this.done = launch === null ? this.settleExpired() : launch(this.console).then(
       (result) => this.settle(result, null),
       (err) => this.settle(null, err)
     );
   }
-  async consume() {
-    for await (const chunk of this.console.follow(0)) {
-      if (chunk.channel === Channel2.CONTROL) return;
-      if (chunk.seq !== this.expectSeq) {
-        this.lossy = true;
-        this.spill?.disable();
-      }
-      this.expectSeq = chunk.seq + 1;
-      await this.appendChunk(chunk);
-    }
+  readStream(tail, fromByte, channel) {
+    const read = tail.readFrom(fromByte);
+    const spillPath = channel === "stdout" ? this.parts.spill?.stdoutPath : this.parts.spill?.stderrPath;
+    return { ...read, ...spillPath !== void 0 ? { spillPath } : {} };
   }
   async appendChunk(chunk) {
-    if (this.spill !== null) await this.spill.ingest(chunk.channel, chunk.data);
+    const spill = this.parts.spill;
+    if (spill !== null) await spill.ingest(chunk.channel, chunk.data);
+    const tail = chunk.channel === Channel.STDERR ? this.stderrTail : this.stdoutTail;
+    tail.append(chunk.data);
     let dropped = false;
-    if (chunk.channel === Channel2.STDERR) {
+    if (chunk.channel === Channel.STDERR) {
       if (!this.inStderr) {
         dropped = this.pending.append(STDERR_MARKER);
         this.inStderr = true;
@@ -208,14 +144,11 @@ var MirageShellProcess = class {
       this.inStderr = false;
     }
     dropped = this.pending.append(chunk.data) || dropped;
-    if (dropped) {
-      this.lossy = true;
-      if (this.spill !== null) await this.spill.begin();
-    }
+    if (dropped) this.lossy = true;
+    if ((dropped || tail.truncated) && spill !== null) await spill.begin();
   }
   async settle(result, err) {
     this.settled = true;
-    if (this.sandboxInfo !== void 0) this.sandbox = this.sandboxInfo;
     let outcome;
     if (result !== null) {
       this.status = "completed";
@@ -224,29 +157,77 @@ var MirageShellProcess = class {
     } else {
       this.status = "killed";
       this.signal = "SIGTERM";
-      const message = err instanceof Error ? err.message : String(err);
-      await this.console.emit(Channel2.STDERR, new TextEncoder().encode(message));
       outcome = KILLED_OUTCOME;
+      if (!this.parts.controller.signal.aborted) {
+        this.failure = { error: err };
+        const message = err instanceof Error ? err.message : String(err);
+        await this.console.emit(Channel.STDERR, new TextEncoder().encode(message));
+      }
+    }
+    if (result !== null) {
+      const before = this.stderrTail.readFrom(0).text;
+      const line = refusalLine(result.refusal);
+      if (line !== "") {
+        const lead = before === "" || before.endsWith("\n") ? "" : "\n";
+        await this.console.emit(Channel.STDERR, new TextEncoder().encode(lead + line));
+      }
     }
     await this.console.finish(outcome);
-    await this.consumed;
+    this.stdoutTail.end();
+    this.stderrTail.end();
+    const stderr = this.stderrTail.readFrom(0).text;
+    const sandbox = this.parts.verdict(result, stderr);
+    if (sandbox !== void 0) this.sandbox = sandbox;
+    this.parts.disarm();
+  }
+  async settleExpired() {
+    this.settled = true;
+    this.status = "killed";
+    await this.console.finish(KILLED_OUTCOME);
+    const sandbox = this.parts.verdict(null, "");
+    if (sandbox !== void 0) this.sandbox = sandbox;
+    this.parts.disarm();
   }
   readOutput() {
     const delta = this.pending.take();
     const lossy = this.lossy;
     this.lossy = false;
+    const spill = this.parts.spill;
     return {
       delta,
       lossy,
-      ...this.spill?.stdoutPath !== void 0 ? { stdoutSpillPath: this.spill.stdoutPath } : {},
-      ...this.spill?.stderrPath !== void 0 ? { stderrSpillPath: this.spill.stderrPath } : {}
+      ...spill?.stdoutPath !== void 0 ? { stdoutSpillPath: spill.stdoutPath } : {},
+      ...spill?.stderrPath !== void 0 ? { stderrSpillPath: spill.stderrPath } : {}
     };
   }
   kill() {
     if (this.settled) return false;
-    this.controller.abort();
+    this.parts.controller.abort();
     return true;
   }
+  result() {
+    this.settledResult ??= this.done.then(() => {
+      if (this.failure !== null) throw this.failure.error;
+      return {
+        exitCode: this.exitCode,
+        signal: this.signal,
+        ...this.parts.classify(),
+        timeoutMs: this.parts.timeoutMs,
+        stdout: this.collected(this.stdoutTail, "stdout"),
+        stderr: this.collected(this.stderrTail, "stderr"),
+        ...this.sandbox !== void 0 ? { sandbox: this.sandbox } : {}
+      };
+    });
+    return this.settledResult;
+  }
+  collected(tail, channel) {
+    const read = this.readStream(tail, 0, channel);
+    return {
+      text: read.text,
+      truncated: read.lossy,
+      ...read.spillPath !== void 0 ? { spillPath: read.spillPath } : {}
+    };
+  }
 };
 var MirageShellExecutor = class extends ShellExecutor {
   static inject = ["mirage"];
@@ -259,6 +240,9 @@ var MirageShellExecutor = class extends ShellExecutor {
   spillDir;
   sessionReady = null;
   readOnlyReady = null;
+  seeding = /* @__PURE__ */ new Map();
+  issued = 0;
+  seeded = /* @__PURE__ */ new Map();
   constructor(ctx, config = {}) {
     super(ctx);
     this.workdir = config.workdir ?? "/";
@@ -292,7 +276,7 @@ var MirageShellExecutor = class extends ShellExecutor {
   async worldWorkdir(spec) {
     if (spec.workdir === "") return "";
     const ws = await this.workspace();
-    if (await ws.fs.isDir(spec.workdir)) return spec.workdir;
+    if (await ws.vfs.isDir(spec.workdir)) return spec.workdir;
     return this.sessionId === void 0 ? this.workdir : "";
   }
   // A spill sink for one background command, or null when no spill
@@ -304,15 +288,15 @@ var MirageShellExecutor = class extends ShellExecutor {
     const target = {
       ensureDir: async (d) => {
         const ws = await this.workspace();
-        await ensureDirPath({ exists: (p) => ws.fs.exists(p), mkdir: (p) => ws.fs.mkdir(p) }, d);
+        await ensureDirPath({ exists: (p) => ws.vfs.exists(p), mkdir: (p) => ws.vfs.mkdir(p) }, d);
       },
       write: async (p, bytes) => {
         const ws = await this.workspace();
-        await ws.fs.writeFile(p, bytes);
+        await ws.vfs.write(p, bytes);
       },
       append: async (p, bytes) => {
         const ws = await this.workspace();
-        await ws.fs.append(p, bytes);
+        await ws.vfs.append(p, bytes);
       }
     };
     spillCounter += 1;
@@ -328,7 +312,7 @@ var MirageShellExecutor = class extends ShellExecutor {
    * workspace-write sandbox: reads and writes land only where mounts
    * (and their modes) allow. Declaring it lets sandbox-aware plugins
    * (dsh's permission presets) compose over this executor. A world
-   * holding a runtime with doors around the gate (the host `local`
+   * holding a runtime with entry points around the gate (the host `local`
    * python, a remote sandbox) voids that claim, so this answers
    * undefined then (the base contract's "does not sandbox") and those
    * plugins refuse to compose instead of trusting a lie.
@@ -385,60 +369,6 @@ var MirageShellExecutor = class extends ShellExecutor {
     if (mode === void 0) return void 0;
     return { mode, denied, enforcement: "full", runnerFailed: false };
   }
-  /**
-   * The retention budget of a background command's console.
-   *
-   * Only the background path caps retention: there a follow loop drains
-   * the console while the command still runs, so the budget bounds what
-   * the loop has not reached yet, and a chunk lost to it is reported as
-   * a gap in the sequence. A foreground console is read once, after the
-   * fact, with nothing to bound.
-   *
-   * @param spec the resolved spec carrying the stdout budget.
-   * @returns the retention budget in bytes.
-   */
-  retentionFor(spec) {
-    return Math.max(spec.stdoutMaxBytes, this.stderrMaxBytes) * CONSOLE_RETENTION_DELTAS;
-  }
-  /**
-   * Take a finished run's two streams off its console, capped, and spill
-   * whichever one lost bytes.
-   *
-   * A foreground run streams into a console rather than returning its
-   * output whole, because mirage throws on abort: bytes a killed command
-   * had already printed are recoverable from a sink and nowhere else.
-   * Only a truncated stream spills, since an untruncated one is already
-   * whole in `text` and writing a file for it would put a copy of every
-   * command's output on a mount. The console this reads is untrimmed, so
-   * a spill is the whole stream rather than the tail of one.
-   *
-   * @param console_ the console this run streamed into.
-   * @param spec the resolved spec carrying the stdout budget.
-   * @returns the capped streams, each with a spill path when it lost bytes.
-   */
-  async collectFrom(console_, spec) {
-    const decoder = new TextDecoder();
-    const outBytes = await console_.snapshot(Channel2.STDOUT);
-    const errBytes = await console_.snapshot(Channel2.STDERR);
-    const stdout = collect(decoder.decode(outBytes), spec.stdoutMaxBytes);
-    const stderr = collect(decoder.decode(errBytes), this.stderrMaxBytes);
-    if (!stdout.truncated && !stderr.truncated) return { stdout, stderr };
-    const spill = this.newSpill();
-    if (spill === null) return { stdout, stderr };
-    if (stdout.truncated) await spill.ingest(Channel2.STDOUT, outBytes);
-    if (stderr.truncated) await spill.ingest(Channel2.STDERR, errBytes);
-    await spill.begin();
-    return {
-      stdout: {
-        ...stdout,
-        ...spill.stdoutPath !== void 0 ? { spillPath: spill.stdoutPath } : {}
-      },
-      stderr: {
-        ...stderr,
-        ...spill.stderrPath !== void 0 ? { spillPath: spill.stderrPath } : {}
-      }
-    };
-  }
   /**
    * Whether this run was refused, by the session's permission document
    * or by the read-only narrowing.
@@ -471,6 +401,7 @@ var MirageShellExecutor = class extends ShellExecutor {
       command: request.command,
       workdir,
       timeoutMs: Math.min(request.timeoutMs ?? this.defaultTimeoutMs, this.maxTimeoutMs),
+      onExpiry: request.onExpiry ?? "kill",
       stdoutMaxBytes: request.stdoutMaxBytes ?? this.stdoutMaxBytes,
       signal: request.signal,
       stdin: request.stdin,
@@ -502,11 +433,9 @@ var MirageShellExecutor = class extends ShellExecutor {
    *
    * @param ws the live workspace holding the session.
    * @param sessionId the session this call runs in.
-   * @param spec the resolved spec carrying the snapshot.
+   * @param managed the call's managed snapshot.
    */
-  async applyManagedEnv(ws, sessionId, spec) {
-    const managed = spec.dshEnv;
-    if (managed === void 0) return;
+  async applyManagedEnv(ws, sessionId, managed) {
     const session = ws.getSession(sessionId);
     const view = sessionView(session);
     for (const key of Object.keys(session.env)) {
@@ -560,15 +489,20 @@ var MirageShellExecutor = class extends ShellExecutor {
     const source = ws.getSession(this.sessionId ?? ws.defaultSessionId);
     const grants = {};
     for (const entry of ws.mounts()) {
-      grants[entry.prefix] = entry.prefix.replace(/\/+$/, "") === SINK_PREFIX ? "exec" : "read";
+      grants[entry.prefix] = rstripSlash(entry.prefix) === SINK_PREFIX ? "exec" : "read";
     }
-    const hide = [...source.hiddenPaths?.paths ?? [], ...source.hiddenPaths?.patterns ?? []];
+    const hidden = source.visibility.paths;
+    const hide = [...hidden?.paths ?? [], ...hidden?.patterns ?? []];
     const twin = ws.createSession(sessionId, {
       mounts: grants,
       ...hide.length > 0 ? { permissions: { paths: { hide } } } : {}
     });
     twin.commands = source.commands;
-    twin.hiddenVars = source.hiddenVars;
+    twin.visibility = {
+      ...twin.visibility,
+      vars: source.visibility.vars,
+      commands: source.visibility.commands
+    };
     setCwd(twin, this.workdir);
     return sessionId;
   }
@@ -578,121 +512,104 @@ var MirageShellExecutor = class extends ShellExecutor {
     if (ws.listSessions().some((s) => s.sessionId === sessionId)) return;
     setCwd(ws.createSession(sessionId), this.workdir);
   }
-  async run(spec) {
-    const sandbox = this.sandboxInfo(spec);
-    if (spec.signal?.aborted === true) {
-      return {
-        exitCode: null,
-        signal: "SIGTERM",
-        timedOut: false,
-        aborted: true,
-        timeoutMs: spec.timeoutMs,
-        stdout: { text: "", truncated: false },
-        stderr: { text: "", truncated: false },
-        ...sandbox !== void 0 ? { sandbox } : {}
-      };
+  /**
+   * Where and as whom one command runs, settled before it starts: the
+   * session binding, the workdir in this world, and its managed env.
+   *
+   * Seeding the env is the one step that writes, so it comes last and
+   * waits for any seed already running on the same session (the bound
+   * one and its read-only twin queue apart). Calls are numbered as they
+   * arrive, and a seed is skipped once a later call has seeded the same
+   * session, so the newest snapshot wins: a slow or abandoned preparation
+   * never lands an old one over it, and a stall before the seed holds up
+   * no other call. A call carrying no snapshot seeds nothing, so it
+   * never counts as the newest, but it still waits for the seeds already
+   * running, so its command never sees one half applied.
+   *
+   * @param spec the resolved spec being prepared.
+   * @returns the workspace, session and workdir the command runs under.
+   */
+  async prepare(spec) {
+    const ticket = ++this.issued;
+    await this.ensureSession();
+    const ws = await this.workspace();
+    const sessionId = await this.sessionFor(spec);
+    const bound = this.sessionId !== void 0;
+    const workdir = await this.worldWorkdir(spec);
+    const managed = spec.dshEnv;
+    if (bound && sessionId !== void 0) {
+      const running = this.seeding.get(sessionId) ?? Promise.resolve();
+      if (managed === void 0) {
+        await running;
+      } else {
+        const seed = running.then(async () => {
+          if (ticket < (this.seeded.get(sessionId) ?? 0)) return;
+          await this.applyManagedEnv(ws, sessionId, managed);
+          this.seeded.set(sessionId, ticket);
+        });
+        this.seeding.set(
+          sessionId,
+          seed.catch(() => void 0)
+        );
+        await seed;
+      }
     }
+    return { ws, sessionId, bound, workdir };
+  }
+  async execute(spec) {
     const controller = new AbortController();
-    const console_ = new JobConsole(new RAMConsoleStore(null));
     let timedOut = false;
     let aborted = false;
-    const timer = setTimeout(() => {
+    const timer = spec.onExpiry === "kill" ? setTimeout(() => {
       timedOut = true;
       controller.abort();
-    }, spec.timeoutMs);
+    }, spec.timeoutMs) : void 0;
     const onAbort = () => {
       if (!timedOut && !aborted) {
         aborted = true;
         controller.abort();
       }
     };
-    spec.signal?.addEventListener("abort", onAbort, { once: true });
-    try {
-      await this.ensureSession();
-      const ws = await this.workspace();
-      const sessionId = await this.sessionFor(spec);
-      const bound = this.sessionId !== void 0;
-      if (bound && sessionId !== void 0) await this.applyManagedEnv(ws, sessionId, spec);
-      const workdir = await this.worldWorkdir(spec);
-      const result = await ws.execute(
-        spec.command,
-        executeOptions(spec, workdir, controller.signal, sessionId, bound, this.workdir, console_)
-      );
-      const captured = await this.collectFrom(console_, spec);
-      const settled = this.sandboxInfo(spec, this.wasDenied(spec, result, captured.stderr.text));
-      return {
-        exitCode: result.exitCode,
-        signal: null,
-        timedOut: false,
-        aborted: false,
-        timeoutMs: spec.timeoutMs,
-        ...captured,
-        ...settled !== void 0 ? { sandbox: settled } : {}
-      };
-    } catch (err) {
-      if (!controller.signal.aborted) throw err;
-      return {
-        exitCode: null,
-        signal: "SIGTERM",
-        timedOut,
-        aborted,
-        timeoutMs: spec.timeoutMs,
-        // Whatever the command printed before the kill landed. GNU's own
-        // timeout keeps it, and a model that watched a build run for two
-        // minutes is owed the log rather than an empty string.
-        ...await this.collectFrom(console_, spec),
-        ...sandbox !== void 0 ? { sandbox } : {}
-      };
-    } finally {
+    if (spec.signal?.aborted === true) onAbort();
+    else spec.signal?.addEventListener("abort", onAbort, { once: true });
+    const disarm = () => {
       clearTimeout(timer);
       spec.signal?.removeEventListener("abort", onAbort);
-    }
-  }
-  start(spec) {
-    const sandbox = this.sandboxInfo(spec);
-    const controller = new AbortController();
-    const console_ = new JobConsole(new RAMConsoleStore(this.retentionFor(spec)));
-    const spill = this.newSpill();
-    if (spec.signal?.aborted === true) {
-      controller.abort();
-      return new MirageShellProcess(
-        Promise.reject(new Error("command aborted before start")),
-        controller,
-        console_,
-        spec.stdoutMaxBytes,
-        spill,
-        sandbox
-      );
-    }
-    const onAbort = () => {
-      controller.abort();
     };
-    spec.signal?.addEventListener("abort", onAbort, { once: true });
-    const run = this.ensureSession().then(async () => {
-      const sessionId = await this.sessionFor(spec);
-      const ws = await this.workspace();
-      const bound = this.sessionId !== void 0;
-      if (bound && sessionId !== void 0) await this.applyManagedEnv(ws, sessionId, spec);
-      return { ws, sessionId, bound, workdir: await this.worldWorkdir(spec) };
-    }).then(
-      ({ ws, sessionId, bound, workdir }) => ws.execute(
+    const parts = {
+      controller,
+      budget: spec.stdoutMaxBytes,
+      stdoutMaxBytes: spec.stdoutMaxBytes,
+      stderrMaxBytes: this.stderrMaxBytes,
+      timeoutMs: spec.timeoutMs,
+      spill: this.newSpill(),
+      classify: () => ({ timedOut, aborted }),
+      verdict: (result, stderr) => this.sandboxInfo(spec, result !== null && this.wasDenied(spec, result, stderr)),
+      disarm
+    };
+    let prepared;
+    try {
+      controller.signal.throwIfAborted();
+      prepared = await untilAborted(this.prepare(spec), controller.signal);
+    } catch (err) {
+      if (!parts.classify().timedOut) {
+        disarm();
+        throw err;
+      }
+      return new MirageShellExecution(null, parts);
+    }
+    const { ws, sessionId, bound, workdir } = prepared;
+    return new MirageShellExecution(
+      (sink) => ws.shell(
         spec.command,
-        executeOptions(
-          spec,
-          workdir,
-          controller.signal,
-          sessionId,
-          bound,
-          this.workdir,
-          console_
-        )
-      )
-    ).finally(() => spec.signal?.removeEventListener("abort", onAbort));
-    return new MirageShellProcess(run, controller, console_, spec.stdoutMaxBytes, spill, sandbox);
+        executeOptions(spec, workdir, controller.signal, sessionId, bound, this.workdir, sink)
+      ),
+      parts
+    );
   }
 };
 
 export {
   MirageShellExecutor
 };
-//# sourceMappingURL=chunk-QTBMLMKT.js.map
+//# sourceMappingURL=chunk-KUIV2Z3M.js.map