@nimbus-sh/worker 0.3.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
@@ -41,7 +44,8 @@ import { generateUndiciShimCode } from '@nimbus-sh/core/runtime/undici-shim.js';
 import { getExportsResolverJS } from '@nimbus-sh/core/_shared/exports-resolver.js';
 import { getTypescriptSpecifiersJS } from '@nimbus-sh/core/_shared/typescript-specifiers.js';
 import { NIMBUS_AI_CREDENTIAL_HEADERS, NIMBUS_AI_TOKEN_ENV } from '@nimbus-sh/core/_shared/ai-egress.js';
-import { FACET_PROVIDED_PACKAGES, FS_READ_BATCH_PATH_LIMIT, FS_READ_BATCH_REQUEST_BYTES, MAX_RPC_SAFE_PAYLOAD_BYTES, NIMBUS_AI_GATEWAY_PORT, NODE_VERSION, NODE_VERSIONS, } from '@nimbus-sh/core/constants.js';
+import { MAX_RPC_SAFE_PAYLOAD_BYTES } from '@nimbus-sh/platform/limits.js';
+import { FACET_PROVIDED_PACKAGES, FS_READ_BATCH_PATH_LIMIT, FS_READ_BATCH_REQUEST_BYTES, NIMBUS_AI_GATEWAY_PORT, NODE_VERSION, NODE_VERSIONS, } from '@nimbus-sh/core/constants.js';
 const STREAMS_CODE = generateStreamsCode();
 const SQLITE_SHIM_CODE = generateSqliteShimCode();
 const UNDICI_SHIM_CODE = generateUndiciShimCode();
@@ -385,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;
@@ -5592,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",
@@ -6151,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) {
@@ -6879,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) {
@@ -6960,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/runtime/opencode-artifact.js

@@ -20,7 +20,7 @@
  * (see OPENCODE_TREE_SITTER_WASMS and FacetManager.treeSitterModuleEntries).
  */
 import { OPENCODE_ARTIFACT_BUILD_ID, OPENCODE_ARTIFACT_DIGESTS, OPENCODE_ARTIFACT_PRESENT, OPENCODE_ARTIFACT_VERSION, } from '../opencode-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /** Base asset path of the staged opencode bundle directory. */
 const OPENCODE_ASSET_BASE = `/_assets/opencode/${OPENCODE_ARTIFACT_VERSION}`;

package/dist/runtime/opentui-wasm-bytes.js

@@ -16,7 +16,7 @@
  * the backend.
  */
 import { OPENTUI_WASM_BUILD_ID, OPENTUI_WASM_ENTRY, OPENTUI_WASM_SHA256, } from '../opentui-wasm-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /**
  * Synthetic L2 cache key for the OpenTUI wasm asset. Build-id-pinned so a

package/dist/runtime/python-repl.js

@@ -207,7 +207,7 @@ class PythonReplAdapter {
         snapshot.files[stdlibPath.replace(/^\/+/, '')] = btoa(bin);
         this.fsSnapshot = snapshot;
         this.pythonHome = `/${installRoot.replace(/^\/+/, '')}`;
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
         const host = getFacetManagerLoaderHost(facetMgr);
         // A prompt where `open(path, "w")` silently does nothing is worse than one
         // that refuses to start, so the pid decides which pool this is. Written as
@@ -225,11 +225,11 @@ class PythonReplAdapter {
         };
         const pid = this.deps.pid;
         this.pool = (typeof pid === 'number' && pid > 0
-            ? new LoaderPool(host.env, host.ctx, { ...base, supervisorPid: pid })
+            ? new IsolatePool(host.env, host.ctx, { ...base, supervisorPid: pid })
             // The install-time warm-up has no invoking process. It boots the
             // interpreter and never touches a file, so it asks for no supervisor
             // rather than binding one it cannot authenticate to.
-            : new LoaderPool(host.env, host.ctx, { ...base, omitSupervisor: true }));
+            : new IsolatePool(host.env, host.ctx, { ...base, omitSupervisor: true }));
     }
     async submit(userCode) {
         const result = await this.pool.submit(pythonReplStepFacetFn, {

package/dist/runtime/ruby-repl.js

@@ -156,10 +156,10 @@ class RubyReplAdapter {
         // drifted (it lacked the language-prelude const __rubyRun requires, so
         // every REPL eval died on boot) — compose it in exactly one place.
         const preamble = buildRubyPreamble();
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
         const env = facetMgr.env;
         const ctx = facetMgr.ctx;
-        this.pool = new LoaderPool(env, ctx, {
+        this.pool = new IsolatePool(env, ctx, {
             tag: 'ruby-repl',
             concurrency: 1,
             omitSupervisor: true,

package/dist/runtime/sqlite-wasm-bytes.js

@@ -17,7 +17,7 @@
  */
 import { SQLJS_VERSION } from '@nimbus-sh/core/constants.js';
 import { SQLITE_WASM_SHA256 } from '../sqlite-wasm-bundle.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /**
  * Path inside env.ASSETS where the sql.js wasm binary lives. Versioned so

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/diag.js

@@ -16,7 +16,7 @@
  *
  * Per DEFECT-D1: ctx is taken as a separate explicit arg.
  */
-import { rehydrateFromStorage, snapshotForStorage, getFailures, } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { rehydrateFromStorage, snapshotForStorage, getFailures, } from '@nimbus-sh/platform/oom-discriminator.js';
 import { W5_RING_STORAGE_KEY } from './keys.js';
 export function readNodeMem() {
     try {

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/hibernation.d.ts

@@ -22,10 +22,10 @@
  *     reason dispatcher with this session's handlers registered.
  *   - flushOnClose(host) — synchronous flush on ws close.
  *
- * The alarm multiplexer itself (reason map, scheduleAlarm, the per-instance
- * chain) and maybeBumpIsolateGen are fabric machinery —
- * `@nimbus-sh/fabric/alarms.js`; this module registers the session's reasons
- * ('w9-flush' | 'log-janitor' | 'resident-launch') on top of it.
+ * The timer multiplexer itself (reason map, schedule, the per-instance
+ * chain) is fabric machinery — `@nimbus-sh/fabric/timers.js`; this module
+ * registers the session's reasons ('w9-flush' | 'log-janitor' |
+ * 'resident-launch') on top of it.
  *
  * **`ctx` taken as a separate arg from `host`** because the parent
  * `CloudflareDurableObject` class declares `ctx` as `protected`, which
@@ -40,7 +40,7 @@
  */
 import type { SessionProcessSupervisor } from '@nimbus-sh/core/runtime/session-process-supervisor.js';
 import { type WsHibernationConfigResult } from '@nimbus-sh/fabric/ws-hibernation-config.js';
-import { type AlarmHost, type IsolateGenHost } from '@nimbus-sh/fabric/alarms.js';
+import { type TimerHost } from '@nimbus-sh/fabric/timers.js';
 export type { WsHibernationConfigResult };
 /**
  * Minimal host shape. `_w9*` fields drop `private` on the class so
@@ -49,7 +49,7 @@ export type { WsHibernationConfigResult };
  *
  * `ctx` is NOT in this interface — passed as a separate arg.
  */
-export interface HibHost extends AlarmHost, IsolateGenHost {
+export interface HibHost extends TimerHost {
     processes: SessionProcessSupervisor;
     _w9SchemaInit: boolean;
     _w9PersistWired: boolean;
@@ -114,7 +114,7 @@ export type AlarmReason = 'w9-flush' | 'log-janitor' | 'resident-launch';
 /**
  * W9: ensure the alarm is set for the next flush window. Cheap to
  * call repeatedly — we only schedule the in-isolate flush timer if
- * it isn't already set. The persistent alarm goes through scheduleAlarm
+ * it isn't already set. The persistent alarm goes through timers.schedule
  * so it coordinates with W1's log-janitor sweep.
  */
 export declare function scheduleHibFlush(host: HibHost, ctx: any): void;
@@ -130,7 +130,7 @@ export declare function scheduleHibFlush(host: HibHost, ctx: any): void;
  * caller (typically `(pid) => !host.processes.get(pid)`). Decoupled
  * so HibHost doesn't need to import ProcessTable.
  */
-export declare function dispatchAlarm(host: HibHost, ctx: any, janitorOrphanCheck?: (pid: number) => boolean, pumpResidentLaunches?: () => Promise<void>): Promise<void>;
+export declare function dispatchAlarm(host: HibHost, ctx: any, janitorOrphanCheck?: (pid: number) => boolean, pumpResidentLaunches?: () => Promise<void>, alarmInfo?: AlarmInvocationInfo): Promise<void>;
 /**
  * W9: synchronous flush of the process-log ring on session close.
  * Wraps `processes.flushLogs()` in a try/catch so a flush failure

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

@@ -1 +1 @@
-{"version":3,"file":"hibernation.d.ts","sourceRoot":"","sources":["../../src/session/hibernation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,EAA0B,KAAK,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACpH,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AAGrC,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS,EAAE,cAAc;IACxD,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,4EAA4E;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,GAAG,yBAAyB,CAY9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CA6GnE;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAc9D;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB7D;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,EAC7C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAMhD"}
+{"version":3,"file":"hibernation.d.ts","sourceRoot":"","sources":["../../src/session/hibernation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,EAA0B,KAAK,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACpH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAGrE,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,4EAA4E;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,GAAG,yBAAyB,CAY9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CA6GnE;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAc9D;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB7D;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,EAC7C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1C,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAMhD"}