@nimbus-sh/worker 0.5.0 → 0.7.0

package/dist/session/ws.d.ts

@@ -37,6 +37,7 @@ import type { SessionProcessSupervisor } from '@nimbus-sh/core/runtime/session-p
 import type { SqliteVFS } from '@nimbus-sh/core/vfs/sqlite-vfs.js';
 import type { CirrusReal } from '../facets/cirrus-real.js';
 import type { WebSocketTerminal } from '../facets/ws-terminal.js';
+import type { InitSessionOptions } from './init.js';
 import type { Kernel, Shell } from '@nimbus-sh/core/substrate/lifo/index.js';
 /**
  * Minimal host shape for WS lifecycle. Per plan §IX.1 b': fields here
@@ -67,9 +68,69 @@ export interface WsHost {
     _w5LastPersistRingSize: number;
     /** [B'.4] live phase indicator — see nimbus-session-internal.d.ts */
     _b4Phase: import('@nimbus-sh/platform/oom-discriminator.js').SessionState | null;
+    /** The session rebuild a woken instance has in flight; see bindShellSocket. */
+    _wakeRebuild: Promise<void> | null;
+    initSession(ws: WebSocket, options?: InitSessionOptions): Promise<void>;
     _w5PersistRing(): Promise<void> | null;
     _w9FlushOnClose(): void;
 }
+/**
+ * Give the shell socket a frame arrived on a live session to land in.
+ *
+ * The runtime evicts a quiet object from memory while its accepted sockets
+ * stay open (the WebSocket Hibernation API), and the next frame from the
+ * peer wakes a fresh instance whose `shell`, `terminal` and `kernel` are
+ * null: the socket outlived the sleep, the session in memory did not.
+ * Measured 2026-09-14 on a deployed Worker: eight quiet seconds and the
+ * object is still there, ten and it is gone; the frame that wakes it is
+ * delivered and handled without error, and the peer gets nothing back —
+ * no output, no close, no error — because the terminal lookup that follows
+ * found nothing to hand it to. Only a new /ws upgrade rebuilt the session,
+ * and a peer whose socket still reads OPEN has no reason to make one. A
+ * browser tab hides this by probing every few seconds; a driver that
+ * simply waits between commands does not.
+ *
+ * So the rebuild runs here, on the socket that spoke, before the frame is
+ * handled: the cold path the upgrade takes after an eviction (cwd, env,
+ * mounts back from SQLite) minus the scrollback replay the peer already has
+ * on screen. Frames that land while the build runs await the same build —
+ * the input gate does not serialise handlers across a non-storage await, so
+ * without the shared promise two quick keystrokes would build two shells.
+ *
+ * A session that exists but answers to another socket — one an SDK call
+ * built on its headless terminal after the same wake — is handed to this
+ * socket the way the warm rejoin hands it to a new upgrade. The upgrade
+ * refuses a second shell socket while one still has a peer, so the socket
+ * that speaks is the one the peer is on.
+ *
+ * A build that fails closes the socket with a reason and answers false, so
+ * the caller drops the frame. The peer must learn that its shell is gone;
+ * the silence this replaces is the whole defect.
+ *
+ * A socket this side has already closed gets no session either: destroy
+ * closes every accepted socket and nulls the terminal before it wipes
+ * storage, and a frame still in flight on one of them must not rebuild
+ * the session it is tearing down.
+ */
+export declare function bindShellSocket(self: WsHost, ws: WebSocket): Promise<boolean>;
+/**
+ * What every output frame of the shell terminal feeds besides the socket:
+ * the persisted scrollback, and the shell-state snapshot.
+ *
+ * The snapshot runs here and not only after each inbound frame because
+ * commands run asynchronously: the `cd` a line asked for takes effect
+ * after the inbound handler has already snapshotted, and the next frame —
+ * which used to catch the row up — never arrives when the object
+ * hibernates first. Measured 2026-09-14: `cd /tmp && echo one`, ten quiet
+ * seconds, and the woken shell answered `pwd` from /home/user. The prompt
+ * that ends every command is an output frame, so by the time it has
+ * flushed, the state it reflects is what the row records.
+ *
+ * Every socket a shell terminal is built on or handed to goes through
+ * this — initSession, the warm rejoin, and the wake rebuild — so the
+ * three cannot drift.
+ */
+export declare function shellTerminalTee(self: WsHost): (frame: string) => void;
 /**
  * Classify a closing/erroring WebSocket by its serialized attachment.
  * Shell sockets carry `{kind:'shell'}` (set at the /ws upgrade site);

package/dist/session/ws.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../src/session/ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAOH,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,eAAe,CAAC;AAIvB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAG7E;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACnC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,mBAAmB,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACnD;;;;8DAI0D;IAC1D,YAAY,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;IAC5C,SAAS,EAAE,wBAAwB,CAAC;IACpC,wBAAwB,EAAE,OAAO,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,GAAG,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,EAAE,OAAO,0CAA0C,EAAE,YAAY,GAAG,IAAI,CAAC;IACjF,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvC,eAAe,IAAI,IAAI,CAAC;CACzB;AAgDD;;;;;;;GAOG;AACH,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AA0CD,wBAAgB,MAAM,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY,CAElD;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CA4EzG;AA+CD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,SAAS,EACb,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,IAAI,CAAC,CAiGf;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CA4EtF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAUlD"}
+{"version":3,"file":"ws.d.ts","sourceRoot":"","sources":["../../src/session/ws.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAQH,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,eAAe,CAAC;AAIvB,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,yCAAyC,CAAC;AAG7E;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,SAAS,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACnC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IAC9B,mBAAmB,EAAE,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACnD;;;;8DAI0D;IAC1D,YAAY,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,UAAU,EAAE,CAAC,CAAC;IAC5C,SAAS,EAAE,wBAAwB,CAAC;IACpC,wBAAwB,EAAE,OAAO,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,GAAG,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,EAAE,OAAO,0CAA0C,EAAE,YAAY,GAAG,IAAI,CAAC;IACjF,+EAA+E;IAC/E,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACnC,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACvC,eAAe,IAAI,IAAI,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBnF;AAsDD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAStE;AAED;;;;;;;GAOG;AACH,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AA6CD,wBAAgB,MAAM,CAAC,EAAE,EAAE,SAAS,GAAG,YAAY,CAElD;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAiFzG;AA+CD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,SAAS,EACb,KAAK,CAAC,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAChB,SAAS,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,IAAI,CAAC,CAiGf;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CA4EtF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAUlD"}

package/dist/session/ws.js

@@ -33,30 +33,97 @@
  * touches ctx.waitUntil; uses `(host.ctx as any)` cast).
  */
 import { dec } from '@nimbus-sh/core/_shared/bytes.js';
+import { errorText } from '@nimbus-sh/core/_shared/error-text.js';
 import { recordFailure, getLastRpcFrame, getLastFacetId, recordRecoveryEvent } from '@nimbus-sh/platform/oom-discriminator.js';
 import { generation } from '@nimbus-sh/fabric/generation.js';
-import { persistShellState } from './state-store.js';
+import { appendScrollback, persistShellState } from './state-store.js';
 import { handleFsWatchSubscribe, handleFsWatchUnsubscribe, cleanupFsWatchOnClose, } from './fs-watch.js';
 import { parseProcessLogClientFrame } from '@nimbus-sh/core/runtime/process-io-protocol.js';
 import { applyProcessClientFrame } from '@nimbus-sh/core/runtime/process-input-routing.js';
 import { z } from 'zod/v4';
 import { clearShellSocketStamp, noteShellSocketActivity } from './shell-socket.js';
 import { PRIOR_GENERATION_EXIT_REASON } from './rpc.js';
+/**
+ * Give the shell socket a frame arrived on a live session to land in.
+ *
+ * The runtime evicts a quiet object from memory while its accepted sockets
+ * stay open (the WebSocket Hibernation API), and the next frame from the
+ * peer wakes a fresh instance whose `shell`, `terminal` and `kernel` are
+ * null: the socket outlived the sleep, the session in memory did not.
+ * Measured 2026-09-14 on a deployed Worker: eight quiet seconds and the
+ * object is still there, ten and it is gone; the frame that wakes it is
+ * delivered and handled without error, and the peer gets nothing back —
+ * no output, no close, no error — because the terminal lookup that follows
+ * found nothing to hand it to. Only a new /ws upgrade rebuilt the session,
+ * and a peer whose socket still reads OPEN has no reason to make one. A
+ * browser tab hides this by probing every few seconds; a driver that
+ * simply waits between commands does not.
+ *
+ * So the rebuild runs here, on the socket that spoke, before the frame is
+ * handled: the cold path the upgrade takes after an eviction (cwd, env,
+ * mounts back from SQLite) minus the scrollback replay the peer already has
+ * on screen. Frames that land while the build runs await the same build —
+ * the input gate does not serialise handlers across a non-storage await, so
+ * without the shared promise two quick keystrokes would build two shells.
+ *
+ * A session that exists but answers to another socket — one an SDK call
+ * built on its headless terminal after the same wake — is handed to this
+ * socket the way the warm rejoin hands it to a new upgrade. The upgrade
+ * refuses a second shell socket while one still has a peer, so the socket
+ * that speaks is the one the peer is on.
+ *
+ * A build that fails closes the socket with a reason and answers false, so
+ * the caller drops the frame. The peer must learn that its shell is gone;
+ * the silence this replaces is the whole defect.
+ *
+ * A socket this side has already closed gets no session either: destroy
+ * closes every accepted socket and nulls the terminal before it wipes
+ * storage, and a frame still in flight on one of them must not rebuild
+ * the session it is tearing down.
+ */
+export async function bindShellSocket(self, ws) {
+    if (ws.readyState !== WS_READY_STATE_OPEN)
+        return false;
+    if (self.shell == null || self.terminal == null || self.kernel == null) {
+        if (!self._wakeRebuild) {
+            self._wakeRebuild = self.initSession(ws, { resume: 'wake' })
+                .finally(() => { self._wakeRebuild = null; });
+        }
+        try {
+            await self._wakeRebuild;
+        }
+        catch (e) {
+            const message = errorText(e);
+            console.error('[nimbus] session rebuild on wake failed:', message);
+            // A close reason is capped at 123 bytes by the protocol.
+            try {
+                ws.close(1011, `session rebuild after wake failed: ${message}`.slice(0, 123));
+            }
+            catch { /* closing */ }
+            return false;
+        }
+        return true;
+    }
+    if (self.terminal.ws !== ws)
+        self.terminal.attach(ws, shellTerminalTee(self));
+    return true;
+}
+/** The shell state each instance last wrote, so an unchanged state costs no SQL. */
+const lastShellSnapshot = new WeakMap();
 /**
  * Snapshot the live Shell state and write it through to DO SQLite
  * [Phase 3 B'.1].
  *
- * Called from wsMessage (post-process, every inbound keystroke) and
- * once more in the wsClose / wsError shell-kind branch as a final
- * safety net before the in-memory Shell is torn down.
+ * Called after every inbound frame, from every output flush of the shell
+ * terminal (see shellTerminalTee), and once more in the wsClose / wsError
+ * shell-kind branch as a final safety net before the in-memory Shell is
+ * torn down.
  *
  * Read-only and synchronous (DO storage SQL is sync inside a request
- * context). Cheap: one read of `shell.getCwd()` + `shell.getEnv()`,
- * a JSON.stringify of env, and an INSERT-OR-REPLACE into the small
- * nimbus_session_kv table. Skips the SQL write entirely when nothing
- * has changed since the previous snapshot — the comparison is
- * pointer-equality on cwd plus env reference, since Shell.getEnv()
- * returns a live Record and `cd` mutates `this.cwd` in place.
+ * context). Cheap: one read of `shell.getCwd()` + `shell.getEnv()` and a
+ * JSON.stringify of env; the INSERT-OR-REPLACE into nimbus_session_kv
+ * only runs when either differs from what this instance last wrote, so
+ * the per-flush call during a chatty command costs a string compare.
  *
  * Failure model: persistShellState throws ONLY on env-too-large
  * (the SESSION_ENV_MAX_BYTES gate). We surface that via console.warn
@@ -88,13 +155,49 @@ function snapshotShellState(self) {
     catch { /* best-effort */ }
     if (!cwd && !env)
         return;
+    const envJson = env ? JSON.stringify(env) : null;
+    const last = lastShellSnapshot.get(self);
+    if (last && last.cwd === cwd && last.envJson === envJson)
+        return;
     try {
         persistShellState(ctx, { cwd, env });
+        lastShellSnapshot.set(self, { cwd, envJson });
     }
     catch (e) {
         console.warn('[nimbus/B\'.1] persistShellState failed:', e?.message || e);
     }
 }
+/**
+ * What every output frame of the shell terminal feeds besides the socket:
+ * the persisted scrollback, and the shell-state snapshot.
+ *
+ * The snapshot runs here and not only after each inbound frame because
+ * commands run asynchronously: the `cd` a line asked for takes effect
+ * after the inbound handler has already snapshotted, and the next frame —
+ * which used to catch the row up — never arrives when the object
+ * hibernates first. Measured 2026-09-14: `cd /tmp && echo one`, ten quiet
+ * seconds, and the woken shell answered `pwd` from /home/user. The prompt
+ * that ends every command is an output frame, so by the time it has
+ * flushed, the state it reflects is what the row records.
+ *
+ * Every socket a shell terminal is built on or handed to goes through
+ * this — initSession, the warm rejoin, and the wake rebuild — so the
+ * three cannot drift.
+ */
+export function shellTerminalTee(self) {
+    // `ctx` is `protected` on the DO base class and so cannot sit on the
+    // host interface (DEFECT-D1); scrollback is the one thing here needing it.
+    const ctx = 'ctx' in self ? self.ctx : undefined;
+    return (frame) => {
+        try {
+            appendScrollback(ctx, frame, Date.now());
+        }
+        catch (e) {
+            console.warn("[B'.3] appendScrollback failed:", errorText(e));
+        }
+        snapshotShellState(self);
+    };
+}
 const WsAttachmentSchema = z.object({
     kind: z.string(),
     clientId: z.string().optional(),
@@ -112,6 +215,8 @@ const FsWatchClientFrameSchema = z.discriminatedUnion('type', [
         subId: z.string().optional(),
     }).passthrough(),
 ]);
+/** `WebSocket.readyState` for an open socket; the constant name differs between workerd and Node. */
+const WS_READY_STATE_OPEN = 1;
 const TerminalMessageSchema = z.object({
     type: z.string(),
     data: z.string().optional(),
@@ -156,8 +261,13 @@ export async function wsMessage(self, ws, message) {
         // The stamp goes in the attachment because isolate memory does not
         // survive hibernation and the /ws upgrade has to read it afterwards.
         // Rate-limited inside; see src/session/shell-socket.ts.
-        if (attach?.kind === 'shell')
+        if (attach?.kind === 'shell') {
             noteShellSocketActivity(ws);
+            // Before the frame is parsed: a woken instance has no session to
+            // hand ANY shell-socket frame to, the liveness probe included.
+            if (!(await bindShellSocket(self, ws)))
+                return;
+        }
         const data = typeof message === 'string' ? message : dec.decode(message);
         const value = JSON.parse(data);
         // file-tree-watch (2026-05-15): handle fs-watch-* on this WS BEFORE
@@ -212,7 +322,7 @@ export async function wsMessage(self, ws, message) {
         // Persist Shell state to DO SQLite after the terminal has handled
         // the user's keystroke. The Shell builtin `cd` mutates this.cwd
         // synchronously inside executeLine, so by the time we reach this
-        // line a `cd app\r` has already taken effect and we capture the
+        // line a `cd example-app\r` has already taken effect and we capture the
         // new cwd. Cheap when nothing has changed; SESSION_ENV_MAX_BYTES
         // is the only failure mode and is logged, not thrown.
         snapshotShellState(self);

package/dist/shell/npm-bin-entrypoints.d.ts

@@ -4,41 +4,6 @@ import type { FacetManager } from '../facets/manager.js';
 type Output = {
     write(data: string): void;
 };
-/**
- * How long a bin invocation may take before the shell stops waiting for it.
- *
- * The program itself is already bounded: FACET_TIMEOUT_MS kills a one-shot
- * facet and the session reports exit 124 with a reason. Nothing bounds the
- * supervisor-side work AROUND that run — the prefetch-bundle walk, the ESM
- * transform, staging a bundled artifact, the loader hop — and nothing bounds
- * the staged-artifact dispatch at all. A dispatch that never settles leaves
- * `running` stuck true on this connection's shell: every later keystroke is
- * swallowed, no prompt returns, and nothing says why. A terminal that goes
- * silent forever is worse than a command that fails.
- *
- * So the invocation gets the program's lifetime twice over: the program keeps
- * its full FACET_TIMEOUT_MS and the supervisor-side work gets the same again.
- * Derived rather than chosen, so it cannot drift from the bound it exists to
- * sit outside. Measured against a deployed Worker, the heaviest bins we run
- * sit far inside it: `pi --version` (a 17.4 MiB module map, the largest
- * observed) returns in 16s, and every staged-opencode one-shot in 2-4s.
- */
-export declare const BIN_DISPATCH_TIMEOUT_MS: number;
-export type BinDispatchOutcome<T> = {
-    expired: false;
-    value: T;
-} | {
-    expired: true;
-};
-/**
- * Await a bin dispatch under a bound. Reports expiry instead of hanging.
- *
- * The abandoned work keeps running — there is nothing to cancel it with, and a
- * facet that eventually finishes still lands its own exit and its write-back.
- * It just no longer holds the shell open, and it can never surface as an
- * unhandled rejection once we have stopped listening.
- */
-export declare function awaitBinDispatch<T>(work: Promise<T>, budgetMs: number): Promise<BinDispatchOutcome<T>>;
 type RegistryLike = {
     resolve(name: string): Promise<unknown> | unknown;
 };

package/dist/shell/npm-bin-entrypoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"npm-bin-entrypoints.d.ts","sourceRoot":"","sources":["../../src/shell/npm-bin-entrypoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,KAAK,EAAE,YAAY,EAA4B,MAAM,sBAAsB,CAAC;AAWnF,KAAK,MAAM,GAAG;IAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,QAAuB,CAAC;AAI5D,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,CAAC;AAErF;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAchC;AA4BD,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC;AAezD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE;IACJ,GAAG,EAAE,eAAe,CAAC;IACrB,MAAM,IAAI,MAAM,CAAC;IACjB,SAAS,EAAE,wBAAwB,CAAC;IACpC,eAAe,IAAI,YAAY,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mBAAmB,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxJ,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC9D,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7F,GACA,IAAI,CA4HN;AA0FD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAEnF,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EAAE,GACb,yBAAyB,CAS3B;AA+FD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAS/E"}
+{"version":3,"file":"npm-bin-entrypoints.d.ts","sourceRoot":"","sources":["../../src/shell/npm-bin-entrypoints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,KAAK,EAAE,YAAY,EAA4B,MAAM,sBAAsB,CAAC;AAWnF,KAAK,MAAM,GAAG;IAAE,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC;AAiB5C,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC;AAezD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,IAAI,EAAE;IACJ,GAAG,EAAE,eAAe,CAAC;IACrB,MAAM,IAAI,MAAM,CAAC;IACjB,SAAS,EAAE,wBAAwB,CAAC;IACpC,eAAe,IAAI,YAAY,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mBAAmB,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACxJ,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC9D,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7F,GACA,IAAI,CAqHN;AAqFD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAEnF,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EAAE,GACb,yBAAyB,CAS3B;AA+FD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAS/E"}

package/dist/shell/npm-bin-entrypoints.js

@@ -2,67 +2,8 @@ import { resolveNpmBin, resolveNpmBinFromPath, isStagedArtifactTarget, stagedArt
 import { bundleProfileForNpmBin } from '@nimbus-sh/core/runtime/bundle-profile.js';
 import { OPENCODE_TREE_SITTER_DIAG_ARG } from '../runtime/opencode-facet-runner.js';
 import { normalizeVfsPath } from '@nimbus-sh/core/vfs/path.js';
-import { DEFAULT_PATH, FACET_TIMEOUT_MS } from '@nimbus-sh/core/constants.js';
+import { DEFAULT_PATH } from '@nimbus-sh/core/constants.js';
 import { z } from 'zod/v4';
-/**
- * How long a bin invocation may take before the shell stops waiting for it.
- *
- * The program itself is already bounded: FACET_TIMEOUT_MS kills a one-shot
- * facet and the session reports exit 124 with a reason. Nothing bounds the
- * supervisor-side work AROUND that run — the prefetch-bundle walk, the ESM
- * transform, staging a bundled artifact, the loader hop — and nothing bounds
- * the staged-artifact dispatch at all. A dispatch that never settles leaves
- * `running` stuck true on this connection's shell: every later keystroke is
- * swallowed, no prompt returns, and nothing says why. A terminal that goes
- * silent forever is worse than a command that fails.
- *
- * So the invocation gets the program's lifetime twice over: the program keeps
- * its full FACET_TIMEOUT_MS and the supervisor-side work gets the same again.
- * Derived rather than chosen, so it cannot drift from the bound it exists to
- * sit outside. Measured against a deployed Worker, the heaviest bins we run
- * sit far inside it: `pi --version` (a 17.4 MiB module map, the largest
- * observed) returns in 16s, and every staged-opencode one-shot in 2-4s.
- */
-export const BIN_DISPATCH_TIMEOUT_MS = 2 * FACET_TIMEOUT_MS;
-const DISPATCH_EXPIRED = Symbol('nimbus.bin-dispatch-expired');
-/**
- * Await a bin dispatch under a bound. Reports expiry instead of hanging.
- *
- * The abandoned work keeps running — there is nothing to cancel it with, and a
- * facet that eventually finishes still lands its own exit and its write-back.
- * It just no longer holds the shell open, and it can never surface as an
- * unhandled rejection once we have stopped listening.
- */
-export async function awaitBinDispatch(work, budgetMs) {
-    let timer;
-    const deadline = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => reject(DISPATCH_EXPIRED), budgetMs);
-    });
-    try {
-        return { expired: false, value: await Promise.race([work, deadline]) };
-    }
-    catch (e) {
-        if (e !== DISPATCH_EXPIRED)
-            throw e;
-        work.catch(() => { });
-        return { expired: true };
-    }
-    finally {
-        if (timer !== undefined)
-            clearTimeout(timer);
-    }
-}
-/**
- * The reason a bin invocation is being abandoned. Names the limit and both
- * numbers it is derived from so the text cannot drift from the code, and says
- * where anything the program still produces will go.
- */
-function dispatchExpiredReason(shellLine, pid) {
-    return `${shellLine}: did not come back after ${BIN_DISPATCH_TIMEOUT_MS / 1000}s — the ` +
-        `${FACET_TIMEOUT_MS / 1000}s a program is given to run, and the same again for the work ` +
-        'around it. The shell is no longer waiting on it' +
-        (pid === null ? '.' : `; anything it still produces goes to the log for pid ${pid}.`);
-}
 const NpmBinPackageMetadataSchema = z.object({
     name: z.string().optional(),
     keywords: z.array(z.string()).optional(),
@@ -135,18 +76,14 @@ export function installNpmBinFallbackResolver(registry, deps) {
             const label = longRunning ? 'started (long-running)' : 'started';
             deps.terminal?.write(`\x1b[2m[bin ${label}: pid=${pid} cmd="${shellLine}"]\x1b[0m\r\n`);
             deps.notifyTerminalEvent({ type: 'spawn', pid, command: shellLine, longRunning, attachedTty });
-            // Once the invocation is abandoned the terminal has moved on to the next
-            // prompt, so late output must not be interleaved into it. The pid's log
-            // still takes everything — that is where the rest of the run shows up.
-            let abandoned = false;
+            // Output goes to the pid's log ring and the caller's streams; nothing
+            // abandons this invocation — it runs until the program exits.
             const writeThrough = (stream, target) => (data) => {
                 const text = String(data);
                 try {
                     deps.processes.appendOutput(pid, stream, text);
                 }
                 catch { }
-                if (abandoned)
-                    return;
                 try {
                     target.write(text);
                 }
@@ -154,7 +91,10 @@ export function installNpmBinFallbackResolver(registry, deps) {
             };
             let exitCode = 1;
             try {
-                const dispatched = await awaitBinDispatch(Promise.resolve(runRuntime({
+                // A user-invoked bin is a foreground program: the shell waits for its
+                // real exit — no dispatch timeout. Ctrl-C ends it through the
+                // terminator the exec path registers on the pid.
+                exitCode = await runRuntime({
                     ...ctx,
                     args: ['/' + bin.targetPath, ...argv],
                     stdout: { write: writeThrough('stdout', ctx.stdout) },
@@ -167,15 +107,7 @@ export function installNpmBinFallbackResolver(registry, deps) {
                         attachedTty,
                     },
                     __nimbusBundleProfile: bundleProfile,
-                })), BIN_DISPATCH_TIMEOUT_MS);
-                if (dispatched.expired) {
-                    writeThrough('stderr', ctx.stderr)(`${dispatchExpiredReason(shellLine, pid)}\n`);
-                    abandoned = true;
-                    exitCode = 124;
-                }
-                else {
-                    exitCode = dispatched.value;
-                }
+                });
             }
             catch (e) {
                 writeThrough('stderr', ctx.stderr)(`bin error: ${formatError(e)}\n`);
@@ -212,21 +144,16 @@ async function runStagedArtifact(deps, name, artifact, argv, cwd, ctx, dispositi
     // Piped stdin is not yet wired for staged artifacts; the interactive TUI reads
     // keystrokes from the live ProcessInputStore via the attached-TTY stdin pump.
     const base = { argv, env: ctx.env ?? {}, cwd, command: shellLine };
-    let dispatched;
+    let result;
     try {
-        dispatched = await awaitBinDispatch(stagedArtifactWork(fm, artifact, base, disposition), BIN_DISPATCH_TIMEOUT_MS);
+        // Same contract as the node-bin path: a user-invoked program runs to
+        // its own exit; the shell does not bound the wait.
+        result = await stagedArtifactWork(fm, artifact, base, disposition);
     }
     catch (e) {
         ctx.stderr.write(`${name}: ${formatError(e)}\n`);
         return 1;
     }
-    // A staged artifact owns its own process-table entry and only tells us the
-    // pid on the way out, so an abandoned dispatch has no pid to point at.
-    if (dispatched.expired) {
-        ctx.stderr.write(`${dispatchExpiredReason(shellLine, null)}\n`);
-        return 124;
-    }
-    const result = dispatched.value;
     // Resident dispositions (dual / server / attached): the facet(s) are now
     // resident, streaming live and reporting their own exit through the
     // supervisor. Surface the long-running spawn and hand off — the same

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/worker",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Nimbus runtime package for Cloudflare Workers, re-exported publicly through @nimbus-sh/sdk/worker.",
   "keywords": [
     "cloudflare",
@@ -53,6 +53,26 @@
       "types": "./dist/_shared/preview-host.d.ts",
       "import": "./dist/_shared/preview-host.js"
     },
+    "./workspace-host": {
+      "workspace": "./src/facets/compose.ts",
+      "types": "./dist/facets/compose.d.ts",
+      "import": "./dist/facets/compose.js"
+    },
+    "./port-capability": {
+      "workspace": "./src/session/port-capability.ts",
+      "types": "./dist/session/port-capability.d.ts",
+      "import": "./dist/session/port-capability.js"
+    },
+    "./durable-slots": {
+      "workspace": "./src/facets/durable-slots.ts",
+      "types": "./dist/facets/durable-slots.d.ts",
+      "import": "./dist/facets/durable-slots.js"
+    },
+    "./git": {
+      "workspace": "./src/git/commands.ts",
+      "types": "./dist/git/commands.d.ts",
+      "import": "./dist/git/commands.js"
+    },
     "./runtime-sync-helper": "./scripts/bundle-runtime.mjs",
     "./public/*": "./public/*",
     "./package.json": "./package.json"
@@ -84,9 +104,9 @@
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "^2.0.41",
-    "@nimbus-sh/core": "^0.7.0",
-    "@nimbus-sh/fabric": "^0.3.0",
-    "@nimbus-sh/platform": "^0.2.0",
+    "@nimbus-sh/core": "^0.9.0",
+    "@nimbus-sh/fabric": "^0.5.0",
+    "@nimbus-sh/platform": "^0.4.0",
     "@renovatebot/pep440": "^5.0.0",
     "ai": "^6.0.182",
     "clean-git-ref": "^2.0.1",