@nimbus-sh/worker 0.3.0 → 0.5.0

package/dist/session/supervisor-rpc.js

@@ -29,15 +29,15 @@
  *   prefetch(cwd, entryCode) → Record<string, string>
  */
 import { WorkerEntrypoint } from 'cloudflare:workers';
-import { setSupervisorEntrypointName } from '@nimbus-sh/fabric/ctx-exports.js';
+import { hostNamespace, hostDispatchMethod } from '@nimbus-sh/platform/composition.js';
 // W5: OOM discriminator — record last-known RPC frame on writeBatch entry
-import { setLastRpcFrame } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { setLastRpcFrame } from '@nimbus-sh/platform/oom-discriminator.js';
 // Phase 2 A'.2 — supervisor in-flight RPC payload byte tracking.
-import { rpcPayloadStart, rpcPayloadEnd } from '@nimbus-sh/core/observability/diag-counters.js';
+import { rpcPayloadStart, rpcPayloadEnd } from '@nimbus-sh/platform/diag-counters.js';
 // W4: R2 cross-tenant npm cache (tarballs + packuments)
 import { R2CacheClient, MAX_R2_TARBALL_BYTES } from '../npm/r2-cache.js';
-import { useRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
-import { W7_MAX_RECORD_BYTES } from '@nimbus-sh/core/_shared/w7-frame.js';
+import { useRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
+import { W7_MAX_RECORD_BYTES } from '@nimbus-sh/platform/w7-frame.js';
 /**
  * Drain the per-call event list captured by R2CacheClient during this
  * SupervisorRPC call.
@@ -75,26 +75,45 @@ function _estimateWriteBatchBytes(payload) {
         n += 80 + (i?.path?.length ?? 0);
     return n;
 }
-// The fabric mints `env.SUPERVISOR` bindings for the programs it hosts;
-// this names the ctx.exports entrypoint those bindings resolve to. Module
-// scope so every isolate that can reach the fabric has it before first use.
-setSupervisorEntrypointName('SupervisorRPC');
+// The fabric mints `env.SUPERVISOR` bindings for the programs it hosts; the
+// worker's composition root (src/index.ts) names this class to the fabric
+// with composeFabric.
 export class SupervisorRPC extends WorkerEntrypoint {
-    /**
-     * The supervisor DO stub for RPC routing, found from the doId in ctx.props.
-     *
-     * Minted per call, because that is the only lifetime an instance of this
-     * class has: workerd constructs a NEW WorkerEntrypoint for every RPC call,
-     * not one per facet invocation, so a field cached here is written and
-     * discarded by the same call and never read by another (measured: two calls
-     * on one stub produced instances #3 and #4, each having served one call).
-     */
-    _getStub() {
+    /** Resolve the composed host anew for each WorkerEntrypoint invocation. */
+    _dispatch() {
         const doId = this.ctx.props?.doId;
-        if (!doId)
+        if (typeof doId !== 'string' || doId.length === 0) {
             throw new Error('SupervisorRPC: missing doId in props');
-        const id = this.env.NIMBUS_SESSION.idFromString(doId);
-        return this.env.NIMBUS_SESSION.get(id);
+        }
+        const binding = hostNamespace();
+        const namespace = Reflect.get(this.env, binding);
+        if (!namespace || typeof namespace.idFromString !== 'function') {
+            throw new Error(`SupervisorRPC: env.${binding} is not a Durable Object namespace; `
+                + "a workspace host names its own with composeFabric({ hostNamespace: '<binding>' })");
+        }
+        const stub = namespace.get(namespace.idFromString(doId));
+        const method = hostDispatchMethod();
+        const dispatch = Reflect.get(stub, method);
+        if (typeof dispatch !== 'function') {
+            throw new Error(`SupervisorRPC: the workspace host mounts no ${method}(); `
+                + 'a host forwards one method to workspace.supervisorOp(op)');
+        }
+        // Never `.call(stub, …)` on an RpcStub: the proxy treats `call` as a
+        // property get, which becomes an RPC to a method literally named "call".
+        // `Reflect.apply` reaches the proxied member's apply trap instead, and on
+        // a plain-object host it still invokes the method with the stub as `this`.
+        return (envelope) => Reflect.apply(dispatch, stub, [envelope]);
+    }
+    _op(op, args = [], extra = {}) {
+        return this._dispatch()({ op, args, ...extra });
+    }
+    /** Stamp filesystem credentials from the binding, not the supplied arguments. */
+    _fsOp(op, args = []) {
+        return this._op(op, args, { pid: this._pid() });
+    }
+    _reportingPid() {
+        const pid = this.ctx.props?.pid;
+        return typeof pid === 'number' && Number.isInteger(pid) && pid > 0 ? pid : 0;
     }
     _call(promise) {
         return useRpcResource(promise, (value) => value);
@@ -115,14 +134,14 @@ export class SupervisorRPC extends WorkerEntrypoint {
     }
     // ── Filesystem RPC ────────────────────────────────────────────────────
     async readFile(path) {
-        return this._call(this._getStub()._rpcReadFile(path, this._pid()));
+        return this._call(this._fsOp('readFile', [path]));
     }
     /**
      * Read a file as raw bytes. Used by the git network facet for binary
      * object/pack files where the text readFile would corrupt content.
      */
     async readFileBytes(path) {
-        return this._call(this._getStub()._rpcReadFileBytes(path, this._pid()));
+        return this._call(this._fsOp('readFileBytes', [path]));
     }
     async writeFile(path, content) {
         // binary-fs wave: accept Uint8Array natively. Pre-fix this RPC was
@@ -130,55 +149,55 @@ export class SupervisorRPC extends WorkerEntrypoint {
         // decode every Uint8Array write — mangling bytes ≥ 0x80 to U+FFFD
         // and corrupting binary content. RPC structured-clone handles
         // Uint8Array transparently; downstream _rpcWriteFile also accepts
-        return this._call(this._getStub()._rpcWriteFile(path, content, this._pid()));
+        return this._call(this._fsOp('writeFile', [path, content]));
     }
     async stat(path) {
-        return this._call(this._getStub()._rpcStat(path, this._pid()));
+        return this._call(this._fsOp('stat', [path]));
     }
     async lstat(path) {
-        return this._call(this._getStub()._rpcLstat(path, this._pid()));
+        return this._call(this._fsOp('lstat', [path]));
     }
     async hasLegacySymlinkUnder(path) {
-        return this._call(this._getStub()._rpcHasLegacySymlinkUnder(path, this._pid()));
+        return this._call(this._fsOp('hasLegacySymlinkUnder', [path]));
     }
     async utimes(path, atimeMs, mtimeMs) {
-        return this._call(this._getStub()._rpcUtimes(path, atimeMs, mtimeMs, this._pid()));
+        return this._call(this._fsOp('utimes', [path, atimeMs, mtimeMs]));
     }
     async chmod(path, mode) {
-        return this._call(this._getStub()._rpcChmod(path, mode, this._pid()));
+        return this._call(this._fsOp('chmod', [path, mode]));
     }
     async access(path, mode) {
-        return this._call(this._getStub()._rpcAccess(path, mode, this._pid()));
+        return this._call(this._fsOp('access', [path, mode]));
     }
     async chown(path, uid, gid, options) {
-        return this._call(this._getStub()._rpcChown(path, uid, gid, this._pid(), options));
+        return this._call(this._fsOp('chown', [path, uid, gid, options]));
     }
     async setUmask(mask) {
-        return this._call(this._getStub()._rpcSetUmask(mask, this._pid()));
+        return this._call(this._fsOp('setUmask', [mask]));
     }
     async readdir(path) {
-        return this._call(this._getStub()._rpcReaddir(path, this._pid()));
+        return this._call(this._fsOp('readdir', [path]));
     }
     async exists(path) {
-        return this._call(this._getStub()._rpcExists(path, this._pid()));
+        return this._call(this._fsOp('exists', [path]));
     }
     async mkdir(path) {
-        return this._call(this._getStub()._rpcMkdir(path, this._pid()));
+        return this._call(this._fsOp('mkdir', [path]));
     }
     async rmdir(path) {
-        return this._call(this._getStub()._rpcRmdir(path, this._pid()));
+        return this._call(this._fsOp('rmdir', [path]));
     }
     async rename(from, to) {
-        return this._call(this._getStub()._rpcRename(from, to, this._pid()));
+        return this._call(this._fsOp('rename', [from, to]));
     }
     async unlink(path) {
-        return this._call(this._getStub()._rpcUnlink(path, this._pid()));
+        return this._call(this._fsOp('unlink', [path]));
     }
     async readlink(path) {
-        return this._call(this._getStub()._rpcReadlink(path, this._pid()));
+        return this._call(this._fsOp('readlink', [path]));
     }
     async symlink(target, path) {
-        return this._call(this._getStub()._rpcSymlink(target, path, this._pid()));
+        return this._call(this._fsOp('symlink', [target, path]));
     }
     /**
      * ACQUIRE: the paths mutated since the facet's cursor, plus a fresh
@@ -192,10 +211,10 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * disposal, which targets the returned value.
      */
     async fsAcquire(epoch, cursor) {
-        return this._call(this._getStub()._rpcFsAcquire(epoch, cursor, this._pid()));
+        return this._call(this._fsOp('fsAcquire', [epoch, cursor]));
     }
     async fsRevision(path) {
-        return this._call(this._getStub()._rpcFsRevision(path, this._pid()));
+        return this._call(this._fsOp('fsRevision', [path]));
     }
     /**
      * Enumerate the session filesystem, one bounded page at a time.
@@ -215,7 +234,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * never mistaken for a complete listing.
      */
     async fsList(after, limit) {
-        return this._call(this._getStub()._rpcFsList(after ?? null, limit ?? null, this._pid()));
+        return this._call(this._fsOp('fsList', [after ?? null, limit ?? null]));
     }
     /**
      * WebSocket relay. A facet does not open its own sockets: the supervisor
@@ -226,28 +245,28 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * facet's next synchronous read serves bytes the authority has replaced.
      */
     async wsOpen(url, protocols) {
-        return this._call(this._getStub()._rpcWsOpen(url, protocols, this._pid()));
+        return this._call(this._fsOp('wsOpen', [url, protocols]));
     }
     async wsPoll(id, waitMs) {
-        return this._call(this._getStub()._rpcWsPoll(id, waitMs, this._pid()));
+        return this._call(this._fsOp('wsPoll', [id, waitMs]));
     }
     async wsSend(id, text, bytes) {
-        return this._call(this._getStub()._rpcWsSend(id, text, bytes, this._pid()));
+        return this._call(this._fsOp('wsSend', [id, text, bytes]));
     }
     async wsClose(id, code, reason) {
-        return this._call(this._getStub()._rpcWsClose(id, code, reason, this._pid()));
+        return this._call(this._fsOp('wsClose', [id, code, reason]));
     }
     async fsOpen(path, flags) {
-        return this._call(this._getStub()._rpcFsOpen(path, flags, this._pid()));
+        return this._call(this._fsOp('fsOpen', [path, flags]));
     }
     async fsRead(handleId, offset, length) {
-        return this._call(this._getStub()._rpcFsRead(handleId, offset, length, this._pid()));
+        return this._call(this._fsOp('fsRead', [handleId, offset, length]));
     }
     async fsWrite(handleId, offset, bytes) {
-        return this._call(this._getStub()._rpcFsWrite(handleId, offset, bytes, this._pid()));
+        return this._call(this._fsOp('fsWrite', [handleId, offset, bytes]));
     }
     async fsClose(handleId) {
-        return this._call(this._getStub()._rpcFsClose(handleId, this._pid()));
+        return this._call(this._fsOp('fsClose', [handleId]));
     }
     /**
      * Stateless ranged ops. Unlike fsOpen/fsRead/fsWrite they carry no
@@ -255,7 +274,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * hibernation and never rewrite whole files for partial updates.
      */
     async fsReadRange(path, offset, length) {
-        return this._call(this._getStub()._rpcFsReadRange(path, offset, length, this._pid()));
+        return this._call(this._fsOp('fsReadRange', [path, offset, length]));
     }
     /**
      * The same read with the session's content cache bypassed, for a boot spec's
@@ -264,7 +283,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * session's heap for the rest of its life.
      */
     async fsReadRangeUncached(path, offset, length) {
-        return this._call(this._getStub()._rpcFsReadRangeUncached(path, offset, length, this._pid()));
+        return this._call(this._fsOp('fsReadRangeUncached', [path, offset, length]));
     }
     /**
      * Read many ranges in ONE round trip — the read-side counterpart to
@@ -288,23 +307,23 @@ export class SupervisorRPC extends WorkerEntrypoint {
         setLastRpcFrame('fsReadBatch', payloadBytes);
         rpcPayloadStart(payloadBytes);
         try {
-            return await this._call(this._getStub()._rpcFsReadBatch(requests, this._pid()));
+            return await this._call(this._fsOp('fsReadBatch', [requests]));
         }
         finally {
             rpcPayloadEnd(payloadBytes);
         }
     }
     async fsWriteRange(path, offset, bytes) {
-        return this._call(this._getStub()._rpcFsWriteRange(path, offset, bytes, this._pid()));
+        return this._call(this._fsOp('fsWriteRange', [path, offset, bytes]));
     }
     async fsAppend(path, moduleId, operationId, bytes) {
-        return this._call(this._getStub()._rpcFsAppend(path, this._writerId(), moduleId, operationId, bytes, this._pid()));
+        return this._call(this._op('fsAppend', [path, moduleId, operationId, bytes], { pid: this._pid(), writerId: this._writerId() }));
     }
     async fsAppendAck(moduleId, operationId) {
-        return this._call(this._getStub()._rpcFsAppendAck(this._writerId(), moduleId, operationId, this._pid()));
+        return this._call(this._fsOp('fsAppendAck', [this._writerId(), moduleId, operationId]));
     }
     async fsTruncate(path, size) {
-        return this._call(this._getStub()._rpcFsTruncate(path, size, this._pid()));
+        return this._call(this._fsOp('fsTruncate', [path, size]));
     }
     /**
      * Bulk-write all inodes + chunks in ONE transactionSync on the supervisor.
@@ -327,7 +346,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
         setLastRpcFrame('writeBatch', payloadBytes);
         rpcPayloadStart(payloadBytes);
         try {
-            return await this._call(this._getStub()._rpcWriteBatch(payload, this._pid()));
+            return await this._call(this._fsOp('writeBatch', [payload]));
         }
         finally {
             rpcPayloadEnd(payloadBytes);
@@ -358,7 +377,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
         rpcPayloadStart(STREAM_RESIDENT_BYTES);
         try {
             const mutationOwner = this.ctx.props?.mutationOwner;
-            return await this._call(this._getStub()._rpcWriteBatchStream(stream, typeof mutationOwner === 'string' ? mutationOwner : undefined, this._pid()));
+            return await this._call(this._op('writeBatchStream', [], { pid: this._pid(), mutationOwner: typeof mutationOwner === 'string' ? mutationOwner : undefined, stream }));
         }
         finally {
             rpcPayloadEnd(STREAM_RESIDENT_BYTES);
@@ -386,7 +405,7 @@ export class SupervisorRPC extends WorkerEntrypoint {
         const payloadBytes = (Array.isArray(entries) ? entries.length : 0) * REGISTRY_ENTRY_BYTES;
         rpcPayloadStart(payloadBytes);
         try {
-            return await this._call(this._getStub()._rpcPutRegistryEntries(entries));
+            return await this._call(this._op('putRegistryEntries', [entries]));
         }
         finally {
             rpcPayloadEnd(payloadBytes);
@@ -479,10 +498,10 @@ export class SupervisorRPC extends WorkerEntrypoint {
     }
     // ── Process I/O ───────────────────────────────────────────────────────
     async stdout(data) {
-        return this._call(this._getStub()._rpcStdout(this.ctx.props?.pid || 0, data));
+        return this._call(this._op('stdout', [data], { pid: this._reportingPid() }));
     }
     async stderr(data) {
-        return this._call(this._getStub()._rpcStderr(this.ctx.props?.pid || 0, data));
+        return this._call(this._op('stderr', [data], { pid: this._reportingPid() }));
     }
     /**
      * Report process exit to the supervisor. Called from the facet's own
@@ -495,18 +514,18 @@ export class SupervisorRPC extends WorkerEntrypoint {
      */
     async reportExit(code, tail) {
         const pid = this.ctx.props?.pid || 0;
-        return this._call(this._getStub()._rpcReportExit(pid, code, tail || ''));
+        return this._call(this._op('reportExit', [code, tail || ''], { pid }));
     }
     // ── Prefetch ──────────────────────────────────────────────────────────
     async prefetch(cwd, entryCode) {
-        return this._call(this._getStub()._rpcPrefetch(cwd, entryCode));
+        return this._call(this._op('prefetch', [cwd, entryCode]));
     }
     // ── Port registration ─────────────────────────────────────────────────
     async registerPort(port) {
-        return this._call(this._getStub()._rpcRegisterPort(this.ctx.props?.pid || 0, port));
+        return this._call(this._op('registerPort', [port], { pid: this._reportingPid() }));
     }
     async unregisterPort(port) {
-        return this._call(this._getStub()._rpcUnregisterPort(port));
+        return this._call(this._op('unregisterPort', [port]));
     }
     /**
      * Route an in-session loopback HTTP request (a facet's fetch to
@@ -521,11 +540,11 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * exactly how PortRegistry.routeRequest returns the facet's Response as-is.
      */
     async routeLoopback(port, request) {
-        return this._getStub()._rpcRouteLoopback(port, request);
+        return this._op('routeLoopback', [port, request]);
     }
     // ── Esbuild transform ─────────────────────────────────────────────────
     async transform(code, loader) {
-        return this._call(this._getStub()._rpcTransform(code, loader));
+        return this._call(this._op('transform', [code, loader]));
     }
     // ── child_process [W8 Phase 1] ────────────────────────────────────────
     //
@@ -534,28 +553,28 @@ export class SupervisorRPC extends WorkerEntrypoint {
     // route through the shared FacetProcessManager.
     //
     async cpSpawn(req) {
-        return this._call(this._getStub()._rpcCpSpawn({ ...req, parentPid: this._pid() }));
+        return this._call(this._op('cpSpawn', [{ ...req, parentPid: this._pid() }]));
     }
     async cpStdinWrite(childPid, data) {
-        return this._call(this._getStub()._rpcCpStdinWrite(childPid, data));
+        return this._call(this._op('cpStdinWrite', [childPid, data]));
     }
     async cpStdinEnd(childPid) {
-        return this._call(this._getStub()._rpcCpStdinEnd(childPid));
+        return this._call(this._op('cpStdinEnd', [childPid]));
     }
     async cpReadStdin(childPid, waitMs) {
-        return this._call(this._getStub()._rpcCpReadStdin(childPid, waitMs));
+        return this._call(this._op('cpReadStdin', [childPid, waitMs]));
     }
     async cpReadOutput(childPid, fd, sinceSeq, waitMs) {
-        return this._call(this._getStub()._rpcCpReadOutput(childPid, fd, sinceSeq, waitMs));
+        return this._call(this._op('cpReadOutput', [childPid, fd, sinceSeq, waitMs]));
     }
     async cpDrainOutput(childPid) {
-        return this._call(this._getStub()._rpcCpDrainOutput(childPid));
+        return this._call(this._op('cpDrainOutput', [childPid]));
     }
     async cpKill(childPid, signal) {
-        return this._call(this._getStub()._rpcCpKill(childPid, signal));
+        return this._call(this._op('cpKill', [childPid, signal]));
     }
     async cpWait(childPid, waitMs) {
-        return this._call(this._getStub()._rpcCpWait(childPid, waitMs));
+        return this._call(this._op('cpWait', [childPid, waitMs]));
     }
     /**
      * child-process isolation gap #1: dispatch a single cp.spawn request inline using
@@ -566,6 +585,6 @@ export class SupervisorRPC extends WorkerEntrypoint {
      * supervisor while keeping the dispatch envelope in a fresh isolate.
      */
     async cpDispatchInline(req, kind) {
-        return this._call(this._getStub()._rpcCpDispatchInline(req, kind));
+        return this._call(this._op('cpDispatchInline', [req, kind]));
     }
 }

package/dist/session/ws.d.ts

@@ -60,15 +60,13 @@ export interface WsHost {
     _w9PersistWired: boolean;
     _w9FlushTimer: any;
     _w9SchemaInit: boolean;
-    _isolateGen: number;
-    _isolateGenPersisted: boolean;
     _w9WsConfig: any;
     _diagPeakRss: number;
     _diagPeakHeapUsed: number;
     _w5LastPersistAt: number;
     _w5LastPersistRingSize: number;
     /** [B'.4] live phase indicator — see nimbus-session-internal.d.ts */
-    _b4Phase: import('@nimbus-sh/core/observability/oom-discriminator.js').SessionState | null;
+    _b4Phase: import('@nimbus-sh/platform/oom-discriminator.js').SessionState | null;
     _w5PersistRing(): Promise<void> | null;
     _w9FlushOnClose(): void;
 }

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;AAMH,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;AAClE,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,MAAM,CAAC;IACpB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,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,oDAAoD,EAAE,YAAY,GAAG,IAAI,CAAC;IAC3F,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,CAuEzG;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,CA4Ff;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAuEtF;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;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"}

package/dist/session/ws.js

@@ -33,12 +33,14 @@
  * touches ctx.waitUntil; uses `(host.ctx as any)` cast).
  */
 import { dec } from '@nimbus-sh/core/_shared/bytes.js';
-import { recordFailure, getLastRpcFrame, getLastFacetId, recordRecoveryEvent } from '@nimbus-sh/core/observability/oom-discriminator.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 { 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';
 /**
  * Snapshot the live Shell state and write it through to DO SQLite
@@ -150,6 +152,12 @@ export async function wsMessage(self, ws, message) {
             await routeProcessLogClientMessage(self, ws, attach, message);
             return;
         }
+        // A frame arriving is the peer proving it is still on this socket.
+        // 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')
+            noteShellSocketActivity(ws);
         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
@@ -303,6 +311,11 @@ export async function wsClose(self, ws, _code, _reason, _wasClean) {
     // wrangler dev) + long-running facets must still survive the
     // terminal reconnect (see 607e472 — do NOT kill running processes
     // here). Only reap per-tab state.
+    // The runtime says this socket is finished, so it no longer holds the
+    // terminal. Drop its liveness stamp before anything else: the frame
+    // that triggered this close stamped it moments ago, and leaving that
+    // behind would make the reconnect look like a second tab.
+    clearShellSocketStamp(ws);
     // ── Phase 3 B'.1: transitionTo('drained') ──────────────────────────
     // The Track B' state-machine transition. Persist final shell
     // state + record a recovery_event BEFORE we null the in-memory
@@ -320,7 +333,7 @@ export async function wsClose(self, ws, _code, _reason, _wasClean) {
             fromState: 'active',
             toState: 'drained',
             trigger: 'ws-close',
-            isolateGen: self._isolateGen,
+            isolateGen: generation(self.ctx),
             dataLoss: false,
             snapshotKeysRehydrated: 0,
         });
@@ -351,10 +364,9 @@ export async function wsClose(self, ws, _code, _reason, _wasClean) {
     // upgrade calls terminal.attach(newWs) to swap in the new socket.
     //
     // Pre-B'.5 we nulled these three fields to avoid two-tab cross-
-    // wiring (the 409 in nimbus-session-routes.ts:97 protected against
-    // overwriting an active shell). With phase=drained surfaced on the
-    // host, the /ws handler can disambiguate "warm session waiting for
-    // rejoin" (warmJoin path) from "active session busy" (still 409).
+    // wiring, which cost every reconnect a full rebuild. The upgrade now
+    // reads the sockets instead: a shell socket a peer still holds is the
+    // busy session it refuses, and this one is closing.
     // Reset the one-shot "wrangler alias" banner so a reconnecting user
     // sees it again — terminal-lifetime state, not session-lifetime.
     self.wranglerAliasBannerShown = false;
@@ -386,6 +398,10 @@ export async function wsError(self, ws, _error) {
         catch { /* best-effort */ }
         return;
     }
+    // Same reasoning as wsClose: this socket stops holding the terminal
+    // here. It matters more on this path, because the handler that just
+    // blew the 5-s cap is the one that stamped the socket.
+    clearShellSocketStamp(ws);
     // ── Phase 3 B'.1: transitionTo('drained') ──────────────────────────
     // Same architectural step as wsClose: persist shell state + record
     // a drained event before nulling. wsError is a different physical
@@ -400,7 +416,7 @@ export async function wsError(self, ws, _error) {
             fromState: 'active',
             toState: 'drained',
             trigger: 'ws-error',
-            isolateGen: self._isolateGen,
+            isolateGen: generation(self.ctx),
             dataLoss: false,
             snapshotKeysRehydrated: 0,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/worker",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Nimbus runtime package for Cloudflare Workers, re-exported publicly through @nimbus-sh/sdk/worker.",
   "keywords": [
     "cloudflare",
@@ -84,8 +84,9 @@
   },
   "dependencies": {
     "@ai-sdk/openai-compatible": "^2.0.41",
-    "@nimbus-sh/core": "^0.5.0",
-    "@nimbus-sh/fabric": "^0.1.0",
+    "@nimbus-sh/core": "^0.7.0",
+    "@nimbus-sh/fabric": "^0.3.0",
+    "@nimbus-sh/platform": "^0.2.0",
     "@renovatebot/pep440": "^5.0.0",
     "ai": "^6.0.182",
     "clean-git-ref": "^2.0.1",