@nimbus-sh/worker 0.4.0 → 0.5.0

package/dist/runtime/node-shims.js

@@ -9,7 +9,10 @@
  *   - events: full EventEmitter
  *   - stream: real Readable/Writable/Transform/Duplex with backpressure
  *   - crypto: createHash (FNV-1a sync, SubtleCrypto async), randomBytes/UUID
- *   - zlib: real gzip/gunzip/deflate via CompressionStream/DecompressionStream
+ *   - zlib: forward to workerd's native node:zlib when the facet real-import
+ *     block materialised (full sync/brotli/stream surface; results are the
+ *     host realm's own Buffers, recognized by the widened isBuffer);
+ *     CompressionStream fallback with honest sync refusal
  *   - dns: real DNS resolution via Cloudflare DNS-over-HTTPS
  *   - http: virtual server with port registry for supervisor routing
  *   - https: fetch()-backed request/get
@@ -386,7 +389,19 @@ const __BufferMod = (() => {
 
   function alloc(n, fill) { const a = new Uint8Array(n); if (fill !== undefined) a.fill(typeof fill === "number" ? fill : 0); return _wrap(a); }
   function allocUnsafe(n) { return _wrap(new Uint8Array(Number(n) || 0)); }
-  function isBuffer(o) { return o instanceof Uint8Array && typeof o.toString === "function" && o.__isBuffer; }
+  // Marker check plus native-brand recognition: forwarded node:* builtins
+  // (zlib streams and results, crypto) hand back the host realm's own Buffer
+  // instances, which carry no __isBuffer marker. Their constructor brand is
+  // the closest cross-realm equivalent of Node's instanceof check, so
+  // Buffer.isBuffer stays truthful across the shim/native boundary instead
+  // of rejecting genuine host Buffers. Always returns a boolean (the old
+  // single-expression form leaked an undefined when the marker was absent).
+  function isBuffer(o) {
+    if (!(o instanceof Uint8Array)) return false;
+    if (o.__isBuffer) return true;
+    const ctor = o.constructor;
+    return typeof ctor === "function" && ctor.name === "Buffer";
+  }
   function concat(bufs, len) {
     const total = len ?? bufs.reduce((s, b) => s + b.length, 0);
     const r = new Uint8Array(total); let off = 0;
@@ -5593,6 +5608,21 @@ const __processMod = {
   },
   platform: "linux", arch: "x64",
   version: ${NODE_VERSION_LITERAL}, versions: ${NODE_VERSIONS_LITERAL},
+  features: Object.freeze({
+    inspector: false,
+    debug: false,
+    uv: false,
+    ipv6: true,
+    tls_alpn: true,
+    tls_sni: true,
+    tls_ocsp: false,
+    tls: true,
+    openssl_is_boringssl: true,
+  }),
+  getBuiltinModule: (specifier) => {
+    const key = String(specifier).replace(/^node:/, "");
+    return Object.prototype.hasOwnProperty.call(builtins, key) ? builtins[key] : undefined;
+  },
   execPath: "/usr/local/bin/node",
   execArgv: [],
   pid: 1, ppid: 0, title: "node",
@@ -6152,10 +6182,295 @@ const __nimbusFacetProvidedPackages = new Set(${FACET_PROVIDED_PACKAGES_LITERAL}
 // timers.setInterval(...)), which clack's spinner — used by
 // create-cloudflare — triggers.
 builtins.timers = { setTimeout: globalThis.setTimeout.bind(globalThis), setInterval: globalThis.setInterval.bind(globalThis), clearTimeout: globalThis.clearTimeout.bind(globalThis), clearInterval: globalThis.clearInterval.bind(globalThis), setImmediate: (fn,...a) => globalThis.setTimeout(fn,0,...a), clearImmediate: globalThis.clearTimeout.bind(globalThis) };
+// ──  zlib ───────────────────────────────────────────────────────────
+//
+// Two runtimes, one surface:
+//   1. Facet templates prepend the static import block
+//      (_shared/real-node-imports.ts), which carries workerd's native
+//      node:zlib — complete at the production compat date: every *Sync
+//      variant, brotli/zstd, crc32, constants, and real streaming create*
+//      factories. Forward verbatim: results are the host realm's own Buffer
+//      instances, and __BufferMod.isBuffer recognizes that brand (see the
+//      Buffer shim), so Buffer checks stay truthful without copying every
+//      result or intercepting stream chunks.
+//   2. Scopes without the import block keep the CompressionStream fallback.
+//      It is async-only by nature; the sync names refuse with an honest,
+//      actionable error instead of pretending.
 builtins.zlib = (() => {
-  function _c(d,a) { const i=typeof d==="string"?new TextEncoder().encode(d):d; return new Response(new Blob([i]).stream().pipeThrough(new CompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
-  function _d(d,a) { const i=d instanceof Uint8Array?d:new Uint8Array(d); return new Response(new Blob([i]).stream().pipeThrough(new DecompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
-  return { gzip:(d,o,cb)=>{if(typeof o==="function")cb=o;_c(d,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}, gunzip:(d,o,cb)=>{if(typeof o==="function")cb=o;_d(d,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}, deflate:(d,o,cb)=>{if(typeof o==="function")cb=o;_c(d,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}, inflate:(d,o,cb)=>{if(typeof o==="function")cb=o;_d(d,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}, gzipSync:()=>{throw new Error("use async gzip()");}, gunzipSync:()=>{throw new Error("use async gunzip()");}, createGzip:()=>new __streamMod.Transform({transform(c,e,cb){_c(c,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}}), createGunzip:()=>new __streamMod.Transform({transform(c,e,cb){_d(c,"gzip").then(r=>cb(null,r)).catch(e=>cb(e));}}), createDeflate:()=>new __streamMod.Transform({transform(c,e,cb){_c(c,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}}), createInflate:()=>new __streamMod.Transform({transform(c,e,cb){_d(c,"deflate").then(r=>cb(null,r)).catch(e=>cb(e));}}), constants:{Z_NO_FLUSH:0,Z_PARTIAL_FLUSH:1,Z_SYNC_FLUSH:2,Z_FULL_FLUSH:3,Z_FINISH:4,Z_BEST_COMPRESSION:9,Z_DEFAULT_COMPRESSION:-1} };
+  const __real = (typeof __real_zlib !== "undefined") ? (__real_zlib.default ?? __real_zlib) : null;
+  if (__real && typeof __real.gzipSync === "function") {
+    const mod = {};
+    // Constants, lookup tables, crc32, and the stream factories/classes pass
+    // through bound to the native module (capitalized names are classes —
+    // binding would strip their prototype and break \`new\`).
+    for (const k of Object.keys(__real)) {
+      const v = __real[k];
+      mod[k] = (typeof v === "function" && /^[a-z]/.test(k)) ? v.bind(__real) : v;
+    }
+    if (__real.promises) mod.promises = __real.promises;
+    mod.default = mod;
+    return mod;
+  }
+  function _c(i,a) { return new Response(new Blob([i]).stream().pipeThrough(new CompressionStream(a))).arrayBuffer().then(ab=>__BufferMod.from(new Uint8Array(ab))); }
+  // Decompression is driven by hand rather than piped: feeding and draining
+  // run together, because a write only completes while somebody reads.
+  async function _d(i,a) {
+    const codec = _openCodec("decompress", a);
+    const chunks = [];
+    let failure = null;
+    const record = (reason) => { if (!failure) failure = { reason }; };
+    const drain = (async () => {
+      for (;;) {
+        const next = await codec.reader.read();
+        if (next.done) return;
+        chunks.push(next.value);
+      }
+    })().catch(record);
+    const feed = (async () => {
+      await codec.writer.write(i);
+      await codec.writer.close();
+    })().catch(record);
+    await Promise.all([drain, feed]);
+    if (failure) throw _decompressFailure(failure.reason);
+    return __BufferMod.from(_concat(chunks));
+  }
+  function _syncRefusal(name, asyncName) {
+    const e = new Error("zlib." + name + ": synchronous compression is not available on this runtime (no native node:zlib in scope). Use the async zlib." + asyncName + "(data, callback) form.");
+    e.code = "ERR_ZLIB_SYNC_UNAVAILABLE";
+    throw e;
+  }
+  // Node accepts strings, ArrayBuffers, and any ArrayBufferView; one funnel
+  // yields a byte-addressed Uint8Array over the caller's own region —
+  // byteOffset/byteLength preserved, element values never reinterpreted.
+  function _u8(d) {
+    if (typeof d === "string") return new TextEncoder().encode(d);
+    if (d instanceof Uint8Array) return d;
+    if (ArrayBuffer.isView(d)) return new Uint8Array(d.buffer, d.byteOffset, d.byteLength);
+    return new Uint8Array(d);
+  }
+  // Node splits decompression failures two ways, and the engine's own
+  // failure is the only thing that can tell them apart: an input that ran
+  // out is Z_BUF_ERROR / errno -5, everything else — bad header, bad block,
+  // and a checksum or length trailer that only fails once the member is
+  // complete — is Z_DATA_ERROR / errno -3. Which side of a write or close
+  // the failure lands on says nothing about that, so it is not consulted.
+  function _zdata(e) {
+    const err = new Error(e instanceof Error && e.message ? e.message : String(e));
+    err.code = "Z_DATA_ERROR";
+    err.errno = -3;
+    err.cause = e;
+    return err;
+  }
+  function _zbuf(e) {
+    const err = new Error("unexpected end of file");
+    err.code = "Z_BUF_ERROR";
+    err.errno = -5;
+    if (e != null) err.cause = e;
+    return err;
+  }
+  function _isUnexpectedEnd(e) {
+    const m = e instanceof Error && typeof e.message === "string" ? e.message : String(e);
+    return /unexpected end|end of (?:file|input|stream)|premature|truncated|\\bEOF\\b/i.test(m);
+  }
+  function _decompressFailure(e) { return _isUnexpectedEnd(e) ? _zbuf(e) : _zdata(e); }
+  function _destroyedWrite() {
+    const e = new Error("Cannot call write after a stream was destroyed");
+    e.code = "ERR_STREAM_DESTROYED";
+    return e;
+  }
+  // Node throws synchronously rather than deferring a callback that is not
+  // there; this surface has no promise form to fall back on.
+  function _invalidCallback(v) {
+    const got = v === undefined ? "undefined"
+      : v === null ? "null"
+      : typeof v === "object" ? "an instance of " + ((v.constructor && v.constructor.name) || "Object")
+      : "type " + typeof v + " (" + String(v) + ")";
+    const e = new TypeError('The "callback" argument must be of type function. Received ' + got);
+    e.code = "ERR_INVALID_ARG_TYPE";
+    return e;
+  }
+  // Node's Unzip contract sniffs the wrapper itself: gzip magic or zlib.
+  function _isGzip(u8) { return u8.length >= 2 && u8[0] === 0x1f && u8[1] === 0x8b; }
+  function _concat(chunks) {
+    let n = 0;
+    for (const c of chunks) n += c.length;
+    const out = new Uint8Array(n);
+    let o = 0;
+    for (const c of chunks) { out.set(c, o); o += c.length; }
+    return out;
+  }
+  function _process(mode, fmt, input) {
+    const algo = mode === "compress" ? fmt : (fmt || (_isGzip(input) ? "gzip" : "deflate"));
+    return mode === "compress" ? _c(input, algo) : _d(input, algo);
+  }
+  function _async(mode, fmt) {
+    return (d, o, cb) => {
+      const callback = typeof o === "function" ? o : cb;
+      if (typeof callback !== "function") throw _invalidCallback(callback);
+      // Two arms, not .then().catch(): a callback that throws on success must
+      // not be handed its own exception as a second, failed invocation.
+      _process(mode, fmt, _u8(d)).then(
+        (r) => callback(null, r),
+        (e) => callback(e instanceof Error ? e : new Error(String(e))),
+      );
+    };
+  }
+  // Live codec per Transform lifetime: every write feeds one real
+  // CompressionStream/DecompressionStream writer (its queue serializes
+  // ordering; the write promise settles before the callback), a reader pump
+  // relays output as it is produced instead of accumulating the payload,
+  // and flush closes the writer then awaits full drain before completing.
+  // Chunks are copied so later caller mutations cannot reach the codec, and
+  // createUnzip holds copies only until two bytes decide the wrapper.
+  function _openCodec(openMode, openAlgo) {
+    const cs = openMode === "compress" ? new CompressionStream(openAlgo) : new DecompressionStream(openAlgo);
+    return { writer: cs.writable.getWriter(), reader: cs.readable.getReader() };
+  }
+  // The legacy Readable has no resume notification, so room below the
+  // high-water mark is observed by yielding to the task queue until the
+  // consumer drains or the stream is destroyed.
+  async function _drainRoom(stream) {
+    while (
+      stream._readableState &&
+      !stream._readableState.destroyed &&
+      stream.readableLength >= stream._readableState.highWaterMark
+    ) {
+      await new Promise((tick) => setTimeout(tick, 0));
+    }
+    // True when the wait ended because the stream went away, not because
+    // the consumer made room.
+    return !!(stream._readableState && stream._readableState.destroyed);
+  }
+  function _streamFactory(factoryMode, fmt) {
+    return () => {
+      let writer = null;
+      let reader = null;
+      let drained = Promise.resolve();
+      let pumpFailure = null;
+      let algo = fmt;
+      let held = [];
+      let heldLen = 0;
+      let destroyed = false;
+      const t = new __streamMod.Transform({
+        transform: async (chunk, _enc, cb) => {
+          try {
+            if (destroyed) return cb(_destroyedWrite());
+            const bytes = _u8(chunk).slice();
+            let feed = bytes;
+            if (!writer) {
+              if (fmt === null && heldLen + bytes.length < 2) {
+                held.push(bytes);
+                heldLen += bytes.length;
+                return cb();
+              }
+              if (heldLen > 0) feed = _concat([...held, bytes]);
+              held = [];
+              heldLen = 0;
+              if (fmt === null) algo = _isGzip(feed) ? "gzip" : "deflate";
+              start();
+            }
+            await writer.write(feed);
+            cb();
+          } catch (e) {
+            cb(destroyed ? _destroyedWrite() : factoryMode === "decompress" ? _decompressFailure(e) : e);
+          }
+        },
+        flush: async (cb) => {
+          try {
+            if (destroyed) return cb(_destroyedWrite());
+            if (!writer) {
+              if (factoryMode !== "compress") {
+                // Nothing was ever fed: the input ended before a member
+                // began, which is Node's unexpected-end buffer error rather
+                // than corrupt data. No codec is invented to hide it.
+                return cb(_zbuf(null));
+              }
+              start();
+            }
+            await writer.close();
+            await drained;
+            cb(pumpFailure);
+          } catch (e) {
+            if (pumpFailure) return cb(pumpFailure);
+            if (destroyed) return cb(_destroyedWrite());
+            cb(factoryMode === "decompress" ? _decompressFailure(e) : e);
+          }
+        },
+      });
+      // Every destroy exit fires 'close' on the custom Transform — even when
+      // the pump sits parked inside reader.read() on truncated input that can
+      // never decode. Waking there is immediate: cancel settles the parked
+      // read, abort fails queued writes, and writes arriving after destroy
+      // report ERR_STREAM_DESTROYED instead of silent acceptance.
+      t.on("close", () => {
+        destroyed = true;
+        _releaseCodec();
+      });
+      // One cleanup path for every destroy exit: cancel the readable side,
+      // abort the writable side, and stop the pump.
+      function _releaseCodec() {
+        if (reader) reader.cancel().catch(() => {});
+        if (writer) writer.abort().catch(() => {});
+      }
+      function start() {
+        const opened = _openCodec(factoryMode, algo);
+        writer = opened.writer;
+        reader = opened.reader;
+        drained = (async () => {
+          try {
+            for (;;) {
+              // A destroy can land while a read is in flight; check on both
+              // sides so nothing buffers after the stream went away.
+              if (destroyed) return _releaseCodec();
+              const next = await reader.read();
+              if (destroyed) return _releaseCodec();
+              if (next.done) {
+                return;
+              }
+              // Backpressure: once push reports pressure, park the pump and
+              // do not read again until the consumer drains below the
+              // high-water mark. The pending writer.write promise then holds
+              // the transform callback, so producer writes stop resolving
+              // instead of accumulating. A destroy while parked releases the
+              // codec through the close hook above.
+              if (!t.push(__BufferMod.from(next.value))) {
+                if (await _drainRoom(t)) return _releaseCodec();
+              }
+            }
+          } catch (e) {
+            pumpFailure = factoryMode === "decompress"
+              ? _decompressFailure(e)
+              : (e instanceof Error ? e : new Error(String(e)));
+          }
+        })();
+      }
+      return t;
+    };
+  }
+  return {
+    gzip: _async("compress", "gzip"),
+    gunzip: _async("decompress", "gzip"),
+    deflate: _async("compress", "deflate"),
+    inflate: _async("decompress", "deflate"),
+    deflateRaw: _async("compress", "deflate-raw"),
+    inflateRaw: _async("decompress", "deflate-raw"),
+    unzip: _async("decompress", null),
+    gzipSync: (d, o) => _syncRefusal("gzipSync", "gzip"),
+    gunzipSync: (d, o) => _syncRefusal("gunzipSync", "gunzip"),
+    deflateSync: (d, o) => _syncRefusal("deflateSync", "deflate"),
+    inflateSync: (d, o) => _syncRefusal("inflateSync", "inflate"),
+    deflateRawSync: (d, o) => _syncRefusal("deflateRawSync", "deflateRaw"),
+    inflateRawSync: (d, o) => _syncRefusal("inflateRawSync", "inflateRaw"),
+    unzipSync: (d, o) => _syncRefusal("unzipSync", "unzip"),
+    createGzip: _streamFactory("compress", "gzip"),
+    createGunzip: _streamFactory("decompress", "gzip"),
+    createDeflate: _streamFactory("compress", "deflate"),
+    createInflate: _streamFactory("decompress", "deflate"),
+    createDeflateRaw: _streamFactory("compress", "deflate-raw"),
+    createInflateRaw: _streamFactory("decompress", "deflate-raw"),
+    createUnzip: _streamFactory("decompress", null),
+    constants: { Z_NO_FLUSH: 0, Z_PARTIAL_FLUSH: 1, Z_SYNC_FLUSH: 2, Z_FULL_FLUSH: 3, Z_FINISH: 4, Z_BEST_COMPRESSION: 9, Z_DEFAULT_COMPRESSION: -1 },
+  };
 })();
 builtins.readline = (() => {
   function emitKeypressEvents(stream) {
@@ -6880,9 +7195,11 @@ function __resolveImportsField(name, fromDir) {
 function __mkCompiledFn(code) {
   const reFn = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+__filename\\s*=/m;
   const reDn = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+__dirname\\s*=/m;
+  const reRequire = /(?:^|\\n|;)\\s*(?:const|let|var)\\s+require\\s*=/m;
   const fnName = reFn.test(code) ? "__filename__nimbus_unused" : "__filename";
   const dnName = reDn.test(code) ? "__dirname__nimbus_unused"  : "__dirname";
-  return new Function("exports", "require", "module", fnName, dnName, code);
+  const requireName = reRequire.test(code) ? "require__nimbus_unused" : "require";
+  return new Function("exports", requireName, "module", fnName, dnName, code);
 }
 
 function __exportsTarget(mod) {
@@ -6961,6 +7278,7 @@ function __loadModule(resolvedPath) {
   };
   scopedRequire.cache = __moduleCache;
   scopedRequire.main = __require.main;
+  mod.require = scopedRequire;
 
   // X.5-M3: thread currently-loading module path through globalThis so the
   // URL shim null-base fallback (in node-shims url module) can compose

package/dist/session/agent.d.ts

@@ -15,6 +15,17 @@ interface AgentStorage {
     delete(key: string): Promise<void>;
     deleteAll(): Promise<void>;
     deleteAlarm(): Promise<void>;
+    list<T = unknown>(options: {
+        prefix: string;
+    }): Promise<Map<string, T>>;
+    transaction<T>(body: (txn: {
+        get(key: string): Promise<unknown>;
+        put(key: string, value: unknown): Promise<void>;
+        delete(key: string): Promise<unknown>;
+        list<T2 = unknown>(options: {
+            prefix: string;
+        }): Promise<Map<string, T2>>;
+    }) => Promise<T>): Promise<T>;
 }
 interface Host extends ProgrammaticHost, SessionAiHost {
     ctx: {

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

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/session/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgCH,OAAO,EASL,KAAK,aAAa,EACnB,MAAM,SAAS,CAAC;AACjB,OAAO,EAUL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAiB3B,UAAU,YAAY;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,UAAU,IAAK,SAAQ,gBAAgB,EAAE,aAAa;IACpD,GAAG,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,CAAC;IAC/B,GAAG,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxD;AAED,UAAU,iBAAiB;IACzB,CAAC,EAAE,CAAC,CAAC;IACL,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AA2BD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2ClG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAQxF"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/session/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAgCH,OAAO,EASL,KAAK,aAAa,EACnB,MAAM,SAAS,CAAC;AACjB,OAAO,EAUL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAiB3B,UAAU,YAAY;IACpB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IACxE,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE;QACzB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE;YAAE,MAAM,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;KAC3E,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/B;AAED,UAAU,IAAK,SAAQ,gBAAgB,EAAE,aAAa;IACpD,GAAG,EAAE;QAAE,OAAO,EAAE,YAAY,CAAA;KAAE,CAAC;IAC/B,GAAG,EAAE,gBAAgB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACxD;AAED,UAAU,iBAAiB;IACzB,CAAC,EAAE,CAAC,CAAC;IACL,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;CACvB;AA2BD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2ClG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAQxF"}

package/dist/session/helpers.js

@@ -370,7 +370,7 @@ export const _CP_PURE_BUILTIN = new Set([
     'sleep', 'date', 'whoami', 'id', 'hostname', 'uname', 'clear',
     'tree', 'find', 'grep', 'head', 'tail', 'wc', 'sort', 'uniq', 'sed',
     'awk', 'xargs', 'tee', 'du', 'diff', 'base64', 'seq', 'realpath',
-    'basename', 'dirname', 'printf', 'sha256sum', 'file', 'xxd',
+    'basename', 'dirname', 'printf', 'sha256sum', 'file', 'xxd', 'od', 'hexdump',
     'chmod', 'chown', 'ln', 'test', '[', 'read', 'exit', 'set', 'shopt',
     'trap', 'umask', 'ulimit', 'which', 'uptime',
 ]);

package/dist/session/init-phases.d.ts

@@ -33,6 +33,7 @@
  * additional ring entries, not replacements.
  */
 import { type SessionState } from '@nimbus-sh/platform/oom-discriminator.js';
+import { type AutoResponseHost } from './shell-socket.js';
 /**
  * Set the current phase + record a transition. Fail-soft on the
  * observability call; the phase update on `self` is direct and
@@ -42,37 +43,30 @@ export declare function setPhase(self: {
     _b4Phase: SessionState | null;
     ctx?: unknown;
 }, toState: SessionState, trigger: string): void;
+type WsUpgradeDecision = 'warm-join' | 'conflict' | 'cold';
 /**
- * [B'.5] Identify the original phase-based warm-rejoin case. The /ws
- * upgrade classifier below also recognizes headless sessions whose
- * lifecycle phase does not describe a real terminal attachment.
+ * Decide what a /ws upgrade should do with the session it lands on.
  *
- * Conditions for warm rejoin:
- *   1. Phase = 'drained' (a wsClose / wsError fired since last init).
- *   2. Kernel + Shell + Terminal are still alive in-memory (the
- *      [B'.5] change to wsClose stopped nulling them).
- *   3. Same isolate (no DO eviction since the close).
+ *   - cold:      no session to join. Either nothing was ever built, or a
+ *                previous teardown left the object half-built. A Shell
+ *                without its Kernel or its Terminal serves nobody, and
+ *                nothing else rebuilds one, so the upgrade does.
+ *   - conflict:  another browser terminal holds this session. The caller
+ *                answers 409, which is what stops two tabs from driving
+ *                one shell. See `shell-socket.ts` for what proves that a
+ *                socket still has a peer on it.
+ *   - warm-join: the session is built and unattended. Skip the rebuild
+ *                and hand the live Shell to the incoming socket.
  *
- */
-export declare function isWarmRejoin(self: {
-    _b4Phase: SessionState | null;
-    shell: any;
-    terminal: any;
-    kernel: any;
-}): boolean;
-type WsUpgradeDecision = 'warm-join' | 'conflict' | 'cold';
-/**
- * Classify a shell WebSocket upgrade from the actual attachment state.
- * A non-null Shell can belong to a headless programmatic boot, so only an
- * open socket tagged as `shell` proves that another browser terminal is
- * currently attached.
+ * The caller classifies BEFORE it accepts the incoming socket, so the
+ * upgrade cannot count itself as the incumbent.
  */
 export declare function classifyWsUpgrade(self: {
-    _b4Phase: SessionState | null;
     shell: unknown;
     terminal: unknown;
     kernel: unknown;
-}, sockets: readonly WebSocket[]): WsUpgradeDecision;
+    ctx?: AutoResponseHost;
+}, sockets: readonly WebSocket[], now?: number): WsUpgradeDecision;
 /**
  * [B'.5] Run the warm-rejoin path. Skips Phase B (kernel + shell are
  * already built and alive in-memory). Phase R loads any state that

package/dist/session/init-phases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAGlG;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;CACxC,GAAG,OAAO,CAKV;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,iBAAiB,CAmBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAsCN"}
+{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAElG,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE7E;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,GAAG,CAAC,EAAE,gBAAgB,CAAC;CACxB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,EAAE,GAAG,GAAE,MAAmB,GAAG,iBAAiB,CAG7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAsCN"}

package/dist/session/init-phases.js

@@ -34,6 +34,7 @@
  */
 import { recordRecoveryEvent } from '@nimbus-sh/platform/oom-discriminator.js';
 import { generation } from '@nimbus-sh/fabric/generation.js';
+import { hasLiveShellOwner } from './shell-socket.js';
 /**
  * Set the current phase + record a transition. Fail-soft on the
  * observability call; the phase update on `self` is direct and
@@ -56,51 +57,26 @@ export function setPhase(self, toState, trigger) {
     catch { /* observability is non-critical */ }
 }
 /**
- * [B'.5] Identify the original phase-based warm-rejoin case. The /ws
- * upgrade classifier below also recognizes headless sessions whose
- * lifecycle phase does not describe a real terminal attachment.
+ * Decide what a /ws upgrade should do with the session it lands on.
  *
- * Conditions for warm rejoin:
- *   1. Phase = 'drained' (a wsClose / wsError fired since last init).
- *   2. Kernel + Shell + Terminal are still alive in-memory (the
- *      [B'.5] change to wsClose stopped nulling them).
- *   3. Same isolate (no DO eviction since the close).
+ *   - cold:      no session to join. Either nothing was ever built, or a
+ *                previous teardown left the object half-built. A Shell
+ *                without its Kernel or its Terminal serves nobody, and
+ *                nothing else rebuilds one, so the upgrade does.
+ *   - conflict:  another browser terminal holds this session. The caller
+ *                answers 409, which is what stops two tabs from driving
+ *                one shell. See `shell-socket.ts` for what proves that a
+ *                socket still has a peer on it.
+ *   - warm-join: the session is built and unattended. Skip the rebuild
+ *                and hand the live Shell to the incoming socket.
  *
+ * The caller classifies BEFORE it accepts the incoming socket, so the
+ * upgrade cannot count itself as the incumbent.
  */
-export function isWarmRejoin(self) {
-    return self._b4Phase === 'drained'
-        && self.shell != null
-        && self.terminal != null
-        && self.kernel != null;
-}
-/**
- * Classify a shell WebSocket upgrade from the actual attachment state.
- * A non-null Shell can belong to a headless programmatic boot, so only an
- * open socket tagged as `shell` proves that another browser terminal is
- * currently attached.
- */
-export function classifyWsUpgrade(self, sockets) {
-    if (isWarmRejoin(self))
-        return 'warm-join';
-    if (self.shell == null)
+export function classifyWsUpgrade(self, sockets, now = Date.now()) {
+    if (self.shell == null || self.terminal == null || self.kernel == null)
         return 'cold';
-    if (self.terminal == null || self.kernel == null)
-        return 'conflict';
-    const hasOpenShellSocket = sockets.some((socket) => {
-        if (socket.readyState !== WebSocket.OPEN)
-            return false;
-        try {
-            const attachment = socket.deserializeAttachment();
-            return typeof attachment === 'object'
-                && attachment !== null
-                && 'kind' in attachment
-                && attachment.kind === 'shell';
-        }
-        catch {
-            return false;
-        }
-    });
-    return hasOpenShellSocket ? 'conflict' : 'warm-join';
+    return hasLiveShellOwner(self.ctx, sockets, now) ? 'conflict' : 'warm-join';
 }
 /**
  * [B'.5] Run the warm-rejoin path. Skips Phase B (kernel + shell are

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

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/session/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AA+EH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;GAQG;AACH,KAAK,QAAQ,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAAE,CAAC;AAa3E,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAosF9E"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/session/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AA8EH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;GAQG;AACH,KAAK,QAAQ,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAAE,CAAC;AAa3E,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAysF9E"}