@nimbus-sh/platform 0.5.1 → 0.7.0

package/dist/composition.d.ts

@@ -66,7 +66,8 @@ export declare const DEFAULT_HOST_DISPATCH_METHOD = "supervisorOp";
  * Compose once per isolate. A second call with the same values is a no-op;
  * a second call with different values throws, naming both, so an embedder
  * whose composition lost to an earlier import learns it at startup rather
- * than from a facet that reached the wrong host.
+ * than from a facet that reached the wrong host. A host without
+ * `enhanced_error_serialization` is refused.
  */
 export declare function composeFabric(value: FabricComposition): void;
 export declare function adoptCtxExports(value: CtxExports): void;

package/dist/composition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,IAAI,GAAG,OAAO,EAAE,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAAC;AAC7F,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,yBAAyB,GAAG,SAAS,CAAC,CAAC;AAC/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEpF,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAI3D;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAmB5D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAEvD;AAED,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,IAAI,qBAAoC,GAAG,yBAAyB,GAAG,IAAI,CAMrI;AAED,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,IAAI,CAExD;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,IAAI,SAAS,GAAG,IAAI,CAO5C;AAED,wBAAgB,mBAAmB,IAAI,mBAAmB,CASzD"}
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,IAAI,GAAG,OAAO,EAAE,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,CAAC;AAC7F,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,yBAAyB,GAAG,SAAS,CAAC,CAAC;AAC/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAEpF,MAAM,WAAW,iBAAiB;IAChC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,gEAAgE;IAChE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,SAAS;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAmC3D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAoB5D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAEvD;AAED,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD;AAED,wBAAgB,oBAAoB,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,IAAI,qBAAoC,GAAG,yBAAyB,GAAG,IAAI,CAMrI;AAED,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,IAAI,CAExD;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,IAAI,SAAS,GAAG,IAAI,CAO5C;AAED,wBAAgB,mBAAmB,IAAI,mBAAmB,CASzD"}

package/dist/composition.js

@@ -2,13 +2,45 @@ export const DEFAULT_HOST_NAMESPACE = 'NIMBUS_SESSION';
 export const DEFAULT_HOST_DISPATCH_METHOD = 'supervisorOp';
 let composition = null;
 let ctxExports = null;
+/**
+ * A program's filesystem errors reach it across workerd RPC, from the host
+ * that answers its supervisor binding, and the program branches on the POSIX
+ * `code` each one carries. workerd carries an error's own properties across
+ * RPC only when the sending AND the receiving isolate have
+ * `enhanced_error_serialization`, on by compatibility date from 2026-04-21:
+ * the serializer writes a native error as a host object with its own
+ * properties only under the flag (src/workerd/jsg/ser.c++,
+ * Serializer::IsHostObject), and the receiver reads that detail back only
+ * under it (src/workerd/jsg/util.c++, decodeTunneledException); see
+ * https://developers.cloudflare.com/workers/runtime-apis/rpc/error-handling/.
+ * Programs load at CF_COMPAT_DATE, past it. The host runs at its embedder's
+ * date, and below it every ENOENT would reach every program as a bare message
+ * it maps to EIO. So composing refuses such a host, wherever it composes
+ * (module scope: the Worker fails at startup; NimbusWorkspace.create: that
+ * call throws), and names both fixes: the flag alone keeps
+ * every other behavior of the embedder's date. Off workerd (bun, node) there
+ * is no RPC hop and no `Cloudflare` global to read.
+ */
+function requireEnhancedErrorSerialization() {
+    // `typeof` of an undeclared global is 'undefined', not a ReferenceError.
+    if (typeof Cloudflare === 'undefined')
+        return;
+    if (Cloudflare.compatibilityFlags.enhanced_error_serialization === true)
+        return;
+    throw new Error('fabric: this Worker runs without the enhanced_error_serialization compatibility flag, so the '
+        + "code on a program's filesystem error (ENOENT, EEXIST, ...) would not survive the RPC back "
+        + 'to it. Add "enhanced_error_serialization" to compatibility_flags in your wrangler config, '
+        + 'or set compatibility_date to 2026-04-21 or later.');
+}
 /**
  * Compose once per isolate. A second call with the same values is a no-op;
  * a second call with different values throws, naming both, so an embedder
  * whose composition lost to an earlier import learns it at startup rather
- * than from a facet that reached the wrong host.
+ * than from a facet that reached the wrong host. A host without
+ * `enhanced_error_serialization` is refused.
  */
 export function composeFabric(value) {
+    requireEnhancedErrorSerialization();
     if (!composition) {
         composition = value;
         return;

package/dist/crc32.d.ts

@@ -0,0 +1,19 @@
+/**
+ * CRC-32 (IEEE 802.3, the zip/gzip/PNG polynomial), the one implementation
+ * every Nimbus caller uses: the W7 write-batch framing and zip archives.
+ *
+ * `crc32(bytes, previous)` has node:zlib's contract: `previous` is the
+ * finished CRC of the bytes before these, so a checksum computed in pieces
+ * equals the checksum of the whole.
+ *
+ * Measured 2026-09-24 (5k files x 2 KiB; 64 MiB in 1 MiB buffers):
+ * node:zlib's crc32 is 5-40x faster than any JavaScript loop in bun, node and
+ * workerd (compat 2026-04-01, nodejs_compat), but each call costs ~0.14 us in
+ * workerd, so below 128 bytes the table loop wins there. It is reached through
+ * `process.getBuiltinModule`, like core's incremental SHA-256, so this module
+ * imports nothing and still loads where node:zlib is absent (a browser,
+ * workerd without nodejs_compat). The JavaScript path is slicing-by-8: 2-3x
+ * the byte-at-a-time table loop in bun and node, and level with it in workerd.
+ */
+export declare function crc32(bytes: Uint8Array, previous?: number): number;
+//# sourceMappingURL=crc32.d.ts.map

package/dist/crc32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../src/crc32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAqCH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,SAAI,GAAG,MAAM,CAiB7D"}

package/dist/crc32.js

@@ -0,0 +1,67 @@
+/**
+ * CRC-32 (IEEE 802.3, the zip/gzip/PNG polynomial), the one implementation
+ * every Nimbus caller uses: the W7 write-batch framing and zip archives.
+ *
+ * `crc32(bytes, previous)` has node:zlib's contract: `previous` is the
+ * finished CRC of the bytes before these, so a checksum computed in pieces
+ * equals the checksum of the whole.
+ *
+ * Measured 2026-09-24 (5k files x 2 KiB; 64 MiB in 1 MiB buffers):
+ * node:zlib's crc32 is 5-40x faster than any JavaScript loop in bun, node and
+ * workerd (compat 2026-04-01, nodejs_compat), but each call costs ~0.14 us in
+ * workerd, so below 128 bytes the table loop wins there. It is reached through
+ * `process.getBuiltinModule`, like core's incremental SHA-256, so this module
+ * imports nothing and still loads where node:zlib is absent (a browser,
+ * workerd without nodejs_compat). The JavaScript path is slicing-by-8: 2-3x
+ * the byte-at-a-time table loop in bun and node, and level with it in workerd.
+ */
+/** Below this many bytes the native call's overhead exceeds the JavaScript loop's work (workerd). */
+const CRC_NATIVE_MIN_BYTES = 128;
+const nativeCrc32 = (() => {
+    try {
+        const crc32 = globalThis.process?.getBuiltinModule?.('node:zlib')?.crc32;
+        return typeof crc32 === 'function' ? crc32 : null;
+    }
+    catch {
+        return null;
+    }
+})();
+/** Eight 256-entry tables: table k maps a byte to its CRC after k further zero bytes. */
+let crcTables = null;
+function createCrcTables() {
+    const table = new Uint32Array(256 * 8);
+    for (let index = 0; index < 256; index++) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit++)
+            value = (value & 1) !== 0 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
+        table[index] = value;
+    }
+    for (let index = 0; index < 256; index++) {
+        let value = table[index];
+        for (let k = 1; k < 8; k++) {
+            value = table[value & 0xff] ^ (value >>> 8);
+            table[k * 256 + index] = value;
+        }
+    }
+    return table;
+}
+export function crc32(bytes, previous = 0) {
+    if (nativeCrc32 !== null && bytes.length >= CRC_NATIVE_MIN_BYTES)
+        return nativeCrc32(bytes, previous) >>> 0;
+    const t = crcTables ??= createCrcTables();
+    let value = ~previous;
+    const length = bytes.length;
+    const whole = length - (length & 7);
+    let i = 0;
+    for (; i < whole; i += 8) {
+        const low = value ^ (bytes[i] | (bytes[i + 1] << 8) | (bytes[i + 2] << 16) | (bytes[i + 3] << 24));
+        const high = bytes[i + 4] | (bytes[i + 5] << 8) | (bytes[i + 6] << 16) | (bytes[i + 7] << 24);
+        value = t[1792 + (low & 0xff)] ^ t[1536 + ((low >>> 8) & 0xff)]
+            ^ t[1280 + ((low >>> 16) & 0xff)] ^ t[1024 + (low >>> 24)]
+            ^ t[768 + (high & 0xff)] ^ t[512 + ((high >>> 8) & 0xff)]
+            ^ t[256 + ((high >>> 16) & 0xff)] ^ t[high >>> 24];
+    }
+    for (; i < length; i++)
+        value = t[(value ^ bytes[i]) & 0xff] ^ (value >>> 8);
+    return ~value >>> 0;
+}

package/dist/diag-counters.d.ts

@@ -75,12 +75,6 @@ export interface DiagCounters {
      * Surfaced as `breakdown.prefetchCacheBytes`. A gauge, not a delta.
      */
     prefetchCacheBytes: number;
-    /**
-     * Bytes retained by the FacetManager's ESM→CJS transform cache, bounded by
-     * ESM_TRANSFORM_CACHE_MAX_BYTES. Surfaced as `breakdown.transformCacheBytes`.
-     * A gauge, not a delta.
-     */
-    transformCacheBytes: number;
     /** Install-facet counters. Populated by npm-installer after a
      *  successful batch-facet dispatch returns. Confirms the install ran
      *  in the facet (tarballsCompleted > 0) and surfaces the
@@ -181,8 +175,6 @@ export declare function prefetchBundleEnd(bytes: number): void;
  * owns the number and reports it whenever it admits or evicts an entry.
  */
 export declare function setPrefetchCacheBytes(bytes: number): void;
-/** Publish the transform cache's live retained total; same contract as above. */
-export declare function setTransformCacheBytes(bytes: number): void;
 /** Fold facet-returned counters into the supervisor's diag state.
  *  Called by npm-installer after the batch-facet returns; aggregates
  *  rather than replaces so multiple install runs in the same DO

package/dist/diag-counters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diag-counters.d.ts","sourceRoot":"","sources":["../src/diag-counters.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"diag-counters.d.ts","sourceRoot":"","sources":["../src/diag-counters.ts"],"names":[],"mappings":"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"}

package/dist/diag-counters.js

@@ -23,7 +23,6 @@ const _counters = {
     inFlightRpcPayloadBytes: 0,
     prefetchBundleBytes: 0,
     prefetchCacheBytes: 0,
-    transformCacheBytes: 0,
     installFacet: {
         tarballsCompleted: 0,
         cumulativeBytesDecoded: 0,
@@ -123,11 +122,6 @@ export function setPrefetchCacheBytes(bytes) {
     const n = Number(bytes);
     _counters.prefetchCacheBytes = Number.isFinite(n) && n > 0 ? n : 0;
 }
-/** Publish the transform cache's live retained total; same contract as above. */
-export function setTransformCacheBytes(bytes) {
-    const n = Number(bytes);
-    _counters.transformCacheBytes = Number.isFinite(n) && n > 0 ? n : 0;
-}
 /** Fold facet-returned counters into the supervisor's diag state.
  *  Called by npm-installer after the batch-facet returns; aggregates
  *  rather than replaces so multiple install runs in the same DO

package/dist/heap-estimate.d.ts

@@ -6,7 +6,7 @@
  * `process.memoryUsage()` returns 0 for every field inside a Durable
  * Object class context (only dynamic-worker isolates under nodejs_compat
  * get the real implementation). The previous `readNodeMem` /
- * `sampleMemory` helpers in nimbus-session-diag.ts called it anyway and
+ * `sampleMemory` helpers in session/diag.ts called it anyway and
  * therefore reported zero forever — useless for verifying memory-
  * containment work in plan §3 Track A'.
  *
@@ -180,12 +180,6 @@ export interface HeapBreakdown {
      * the cache holds rather than a reservation it might use.
      */
     prefetchCacheBytes: number;
-    /**
-     * Bytes retained by the FacetManager's ESM→CJS transform cache
-     * (diag-counters `transformCacheBytes`), the other cache that persists
-     * across execs. Bounded by ESM_TRANSFORM_CACHE_MAX_BYTES.
-     */
-    transformCacheBytes: number;
     /**
      * Shared-budget occupancy not already represented by the named transient
      * counters. This covers full-budget owners and keeps cross-DO module-local

package/dist/heap-estimate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heap-estimate.d.ts","sourceRoot":"","sources":["../src/heap-estimate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,wBAAwB,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,sFAM1B,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAAO,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,SAAS,EAAE,aAAa,CAAC;IACzB;;;OAGG;IACH,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IACrC;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,gBAAgB,EAAE,+BAA+B,CAAC;CACnD;AAED,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,uBAAuB,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;sEAEkE;IAClE,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAQnE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,aAAa,GACjB,YAAY,CAoDd"}
+{"version":3,"file":"heap-estimate.d.ts","sourceRoot":"","sources":["../src/heap-estimate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAOH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,wBAAwB,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,sFAM1B,CAAC;AAEX;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,aAAa,EAAO,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,gEAAgE;IAChE,SAAS,EAAE,aAAa,CAAC;IACzB;;;OAGG;IACH,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;IACrC;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,gBAAgB,EAAE,+BAA+B,CAAC;CACnD;AAED,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,uBAAuB,EAAE,MAAM,CAAC;IAChC,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,gBAAgB,EAAE,MAAM,CAAC;IACzB;;sEAEkE;IAClE,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,4BAA4B,EAAE,MAAM,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,YAAY,GAAG,MAAM,CAQnE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,aAAa,GACjB,YAAY,CAkDd"}

package/dist/heap-estimate.js

@@ -6,7 +6,7 @@
  * `process.memoryUsage()` returns 0 for every field inside a Durable
  * Object class context (only dynamic-worker isolates under nodejs_compat
  * get the real implementation). The previous `readNodeMem` /
- * `sampleMemory` helpers in nimbus-session-diag.ts called it anyway and
+ * `sampleMemory` helpers in session/diag.ts called it anyway and
  * therefore reported zero forever — useless for verifying memory-
  * containment work in plan §3 Track A'.
  *
@@ -160,7 +160,6 @@ export function estimateSupervisorHeap(c, vfs) {
         streamingBuffersBytes: c.inFlightRpcPayloadBytes,
         prefetchBundleBytes: c.prefetchBundleBytes,
         prefetchCacheBytes: c.prefetchCacheBytes,
-        transformCacheBytes: c.transformCacheBytes,
         unattributedReservationBytes: Math.max(0, allocationBudget.current - transientAttributedBytes),
     };
     const estimatedBytes = breakdown.supervisorBaselineBytes +
@@ -170,7 +169,6 @@ export function estimateSupervisorHeap(c, vfs) {
         breakdown.streamingBuffersBytes +
         breakdown.prefetchBundleBytes +
         breakdown.prefetchCacheBytes +
-        breakdown.transformCacheBytes +
         breakdown.unattributedReservationBytes;
     const percentOfCeiling = Math.round((estimatedBytes / SUPERVISOR_HEAP_CEILING_BYTES) * 1000) / 10;
     return {

package/dist/heavy-alloc-coord.d.ts

@@ -13,8 +13,6 @@ export interface SupervisorAllocationBudgetStats {
     readonly current: number;
     readonly peak: number;
     readonly queued: number;
-    /** Credit held for an owner's whole lifetime; see `acquireResident`. */
-    readonly resident: number;
 }
 interface AllocationBudgetLifecycle {
     onActive?: () => void;
@@ -53,12 +51,6 @@ export declare class SupervisorAllocationBudget {
      * stops a large read overlapping a large write.
      */
     acquireWithoutLifecycle(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
-    /**
-     * Reserve bytes an owner holds for its whole lifetime, not for one
-     * operation. Recorded as a floor: a later claim larger than what remains
-     * around it is refused with both numbers rather than parked forever.
-     */
-    acquireResidentBytes(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
     private _acquire;
 }
 /**
@@ -91,11 +83,6 @@ export declare function acquireSupervisorAllocation(bytes: number, signal?: Abor
  * there to fill.
  */
 export declare function acquireSupervisorReadAllocation(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
-/**
- * Reserve bytes for the whole life of the owner that takes them — an image
- * a pool keeps until it is disposed. See `acquireResidentBytes`.
- */
-export declare function acquireResidentSupervisorAllocation(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
 /**
  * Reserve the full budget for an allocation whose retained size is not known
  * accurately enough to overlap safely with other heavy work.

package/dist/heavy-alloc-coord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heavy-alloc-coord.d.ts","sourceRoot":"","sources":["../src/heavy-alloc-coord.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,yBAAyB;IACjC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,0BAA0B;IAWnC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAX5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAAK;gBAGlB,QAAQ,EAAE,MAAM,EACR,SAAS,GAAE,yBAA8B,EAC1D,OAAO,GAAE,yBAA8B;IAKzC,IAAI,KAAK,IAAI,+BAA+B,CAK3C;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI3E;;;;;;;;OAQG;IACH,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI3F;;;;OAIG;IACH,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;YAI1E,QAAQ;CAsCvB;AAED;;;GAGG;AACH,UAAU,aAAa;IACrB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,IAAI,CAWlE;AAqCD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAE/B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAE/B;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAE/B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAMjF;AAED,wBAAgB,8BAA8B,IAAI,+BAA+B,CAEhF"}
+{"version":3,"file":"heavy-alloc-coord.d.ts","sourceRoot":"","sources":["../src/heavy-alloc-coord.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAOH,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAC/B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,UAAU,yBAAyB;IACjC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,0BAA0B;IAWnC,QAAQ,CAAC,QAAQ,EAAE,MAAM;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAX5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,MAAM,CAAS;IACvB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB,CAAK;gBAGlB,QAAQ,EAAE,MAAM,EACR,SAAS,GAAE,yBAA8B,EAC1D,OAAO,GAAE,yBAA8B;IAKzC,IAAI,KAAK,IAAI,+BAA+B,CAK3C;IAED;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAI3E;;;;;;;;OAQG;IACH,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;YAI7E,QAAQ;CAmCvB;AAED;;;GAGG;AACH,UAAU,aAAa;IACrB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;CACxB;AAiBD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM,IAAI,CAWlE;AAqCD;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAE/B;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,oBAAoB,CAAC,CAE/B;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAMjF;AAED,wBAAgB,8BAA8B,IAAI,+BAA+B,CAEhF"}

package/dist/heavy-alloc-coord.js

@@ -55,18 +55,8 @@ export class SupervisorAllocationBudget {
     acquireWithoutLifecycle(bytes, signal) {
         return this._acquire(bytes, signal, false);
     }
-    /**
-     * Reserve bytes an owner holds for its whole lifetime, not for one
-     * operation. Recorded as a floor: a later claim larger than what remains
-     * around it is refused with both numbers rather than parked forever.
-     */
-    acquireResidentBytes(bytes, signal) {
-        return this._acquire(bytes, signal, true, true);
-    }
-    async _acquire(bytes, signal, drivesLifecycle, resident = false) {
-        const credit = resident
-            ? await this.credits.acquireResident(bytes, signal)
-            : await this.credits.acquire(bytes, signal);
+    async _acquire(bytes, signal, drivesLifecycle) {
+        const credit = await this.credits.acquire(bytes, signal);
         if (drivesLifecycle) {
             this.lifecycleHolders++;
             if (!this.active) {
@@ -178,13 +168,6 @@ export function acquireSupervisorAllocation(bytes, signal) {
 export function acquireSupervisorReadAllocation(bytes, signal) {
     return supervisorAllocationBudget.acquireWithoutLifecycle(bytes, signal);
 }
-/**
- * Reserve bytes for the whole life of the owner that takes them — an image
- * a pool keeps until it is disposed. See `acquireResidentBytes`.
- */
-export function acquireResidentSupervisorAllocation(bytes, signal) {
-    return supervisorAllocationBudget.acquireResidentBytes(bytes, signal);
-}
 /**
  * Reserve the full budget for an allocation whose retained size is not known
  * accurately enough to overlap safely with other heavy work.

package/dist/limits.d.ts

@@ -38,6 +38,7 @@ export declare const SQL_MAX_BOUND_PARAMETERS = 100;
  * clone, with reserve.
  */
 export declare const DO_STORAGE_LIMIT_BYTES = 10000000000;
+export declare const HYDRATION_DEADLINE_MS = 30000;
 /**
  * Maximum SQL statement text per exec. Documented "100 KB"; read as binary
  * KiB because the value is SQLite's compile-time SQLITE_MAX_SQL_LENGTH
@@ -93,7 +94,7 @@ export declare const RESIDENT_KEEPALIVE_MS = 5000;
 export declare const RESIDENT_KEEPALIVE_DETACHED_MS = 60000;
 /**
  * Bytes one hibernatable WebSocket attachment may serialize to. Verified in
- * workerd source at the pinned version (v1.20260603.1,
+ * workerd source at the pinned version (v1.20260926.1,
  * src/workerd/api/web-socket.h: `MAX_ATTACHMENT_SIZE = 1024 * 16`). The
  * bound is on the SERIALIZED bytes — workerd re-serializes on every
  * `serializeAttachment` call to check it — not on UTF-8 JSON text, so a
@@ -103,7 +104,9 @@ export declare const RESIDENT_KEEPALIVE_DETACHED_MS = 60000;
  */
 export declare const WS_ATTACHMENT_LIMIT_BYTES = 16384;
 export declare const MAX_RPC_SAFE_PAYLOAD_BYTES: number;
+export declare const ONE_SHOT_MODULE_MAP_MAX_BYTES: number;
 export declare const SUPERVISOR_HEAP_CEILING_BYTES: number;
+export declare const FACET_OWN_WRITE_MEMORY_BYTES: number;
 export declare const SUPERVISOR_IN_FLIGHT_ALLOCATION_BUDGET_BYTES: number;
 export declare const SUPERVISOR_READ_RESERVE_BYTES: number;
 export declare const MAX_GLOBAL_WRITE_STREAM_CREDIT_BYTES: number;

package/dist/limits.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../src/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAS,CAAC;AAEjC,eAAO,MAAM,iBAAiB,QAAkB,CAAC;AACjD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAI5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,cAAiB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,UAAY,CAAC;AAI9C;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAIlD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAIrD;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAOhD,eAAO,MAAM,0BAA0B,QAAmB,CAAC;AA6B3D,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AAO9D,eAAO,MAAM,4CAA4C,QAAmB,CAAC;AAY7E,eAAO,MAAM,6BAA6B,QAAc,CAAC;AAKzD,eAAO,MAAM,oCAAoC,QAAkB,CAAC;AAQpE,eAAO,MAAM,0BAA0B,QAA6B,CAAC;AACrE,eAAO,MAAM,sBAAsB,IAAI,CAAC"}
+{"version":3,"file":"limits.d.ts","sourceRoot":"","sources":["../src/limits.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AASH;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAS,CAAC;AAEjC,eAAO,MAAM,iBAAiB,QAAkB,CAAC;AACjD,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAI5C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,cAAiB,CAAC;AAMrD,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,QAAa,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,MAAM,CAAC;AAE/C;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,UAAY,CAAC;AAI9C;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAIlD;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,OAAQ,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,QAAS,CAAC;AAIrD;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAOhD,eAAO,MAAM,0BAA0B,QAAmB,CAAC;AAmB3D,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AA6B9D,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AAM9D,eAAO,MAAM,4BAA4B,QAAmB,CAAC;AAO7D,eAAO,MAAM,4CAA4C,QAAmB,CAAC;AAY7E,eAAO,MAAM,6BAA6B,QAAc,CAAC;AAKzD,eAAO,MAAM,oCAAoC,QAAkB,CAAC;AAQpE,eAAO,MAAM,0BAA0B,QAA6B,CAAC;AACrE,eAAO,MAAM,sBAAsB,IAAI,CAAC"}

package/dist/limits.js

@@ -45,6 +45,11 @@ export const SQL_MAX_BOUND_PARAMETERS = 100;
  * clone, with reserve.
  */
 export const DO_STORAGE_LIMIT_BYTES = 10_000_000_000;
+// N17: how long a launch that reads synchronously (WASI) waits for the paths
+// it names to hydrate out of a lazy import before it fails with EIO naming
+// the first that is not local. Bounded so a fetch that never resolves cannot
+// hold a launch forever.
+export const HYDRATION_DEADLINE_MS = 30_000;
 /**
  * Maximum SQL statement text per exec. Documented "100 KB"; read as binary
  * KiB because the value is SQLite's compile-time SQLITE_MAX_SQL_LENGTH
@@ -103,7 +108,7 @@ export const RESIDENT_KEEPALIVE_DETACHED_MS = 60_000;
 // ── WebSocket attachment bound ──────────────────────────────────────────
 /**
  * Bytes one hibernatable WebSocket attachment may serialize to. Verified in
- * workerd source at the pinned version (v1.20260603.1,
+ * workerd source at the pinned version (v1.20260926.1,
  * src/workerd/api/web-socket.h: `MAX_ATTACHMENT_SIZE = 1024 * 16`). The
  * bound is on the SERIALIZED bytes — workerd re-serializes on every
  * `serializeAttachment` call to check it — not on UTF-8 JSON text, so a
@@ -117,6 +122,24 @@ export const WS_ATTACHMENT_LIMIT_BYTES = 16_384;
 // The platform limit is 32 MiB; 28 MiB leaves room for structured-clone
 // metadata and matches the proven on-demand facet transfer envelope.
 export const MAX_RPC_SAFE_PAYLOAD_BYTES = 28 * 1024 * 1024;
+// ── A one-shot's module map [#13] ───────────────────────────────────────
+//
+// The largest one-shot module map (its closure's raw bytes) the session DO
+// builds and hands to the Worker Loader. What limits it is the DO, not the
+// loader (whose documented limits are concurrency only): the map is built,
+// serialized and passed on from the DO's 128 MB isolate.
+//
+// Measured on a throwaway (2026-09-26; session DO max memoryUsageBytes from
+// GraphQL durableObjectsPeriodicGroups, one launch per minute; a package of
+// 256 KiB distinct modules required whole, verify/release/do-headroom.md),
+// with the map serialized one side module at a time:
+//   4 MiB 64 MB, 8 MiB 81 MB, 12 MiB 97 MB, 16 MiB 110 MB, 20 MiB 126 MB,
+//   24 MiB 145 MB, 28 MiB 164 MB, over an idle 40-55 MB.
+// That is about 4.5 MB of DO per MiB of map. 18 MiB, about 118 MB, is the
+// largest size that leaves about 10 MB of the 128 MB for the rest of the
+// session's work. (Before the single-copy build it was 6-7 MB per MiB: 24 MiB
+// reset the DO.)
+export const ONE_SHOT_MODULE_MAP_MAX_BYTES = 18 * 1024 * 1024;
 // ── Supervisor heap budget [C'.1] ───────────────────────────────────────
 //
 // Three distinct memory regimes, not one shared pool:
@@ -145,6 +168,11 @@ export const MAX_RPC_SAFE_PAYLOAD_BYTES = 28 * 1024 * 1024;
 // sites known to be missing are listed in HEAP_BLIND_SPOTS. Read a low
 // percentOfCeiling accordingly.
 export const SUPERVISOR_HEAP_CEILING_BYTES = 64 * 1024 * 1024;
+// A process facet's own writes its store could not hold (N18: the session's
+// storage is full) are kept in its heap instead, so a write-then-read still
+// works: at most this many bytes, least recently used out first. An eighth
+// of a facet's measured ~208-256 MiB, the rest left to the program.
+export const FACET_OWN_WRITE_MEMORY_BYTES = 32 * 1024 * 1024;
 // Shared allowance for transient allocations in the supervisor DO. With the
 // VFS LRU shrunk to 8 MiB during an active reservation, 40 MiB of admitted
 // payload plus the 9 MiB bundle baseline stays below the 64 MiB soft ceiling

package/dist/oom-classify.d.ts

@@ -123,7 +123,7 @@ export declare function isTransientDoReset(input: unknown): boolean;
 export declare function isDoOverloaded(input: unknown): boolean;
 /**
  * How one failed Durable Object call relates to a retry. The taxonomy
- * Proteus hand-wrote in `cf-backend/src/lib/do-rpc.ts:71-79` because the
+ * Proteus originally hand-wrote in `cf-backend/src/lib/do-rpc.ts` because the
  * Agents SDK does not export its own, plus the `overloaded` class both
  * consumers need: Cloudflare documents that errors carry `.retryable` and
  * `.overloaded`, that a retryable error should be retried with backoff on a

package/dist/oom-classify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oom-classify.d.ts","sourceRoot":"","sources":["../src/oom-classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,QAAA,MAAM,UAAU,kLAYN,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;AAEjD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAItD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAkErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW;AACrB,8CAA8C;AAC5C,oBAAoB;AACtB,8CAA8C;GAC5C,iBAAiB;AACnB,uEAAuE;GACrE,eAAe;AACjB,wDAAwD;GACtD,gBAAgB;AAClB;kDACkD;GAChD,YAAY;AACd,kEAAkE;GAChE,WAAW,CAAC;AAEhB;2DAC2D;AAC3D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAK7D;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAsB1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAgBpD"}
+{"version":3,"file":"oom-classify.d.ts","sourceRoot":"","sources":["../src/oom-classify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,QAAA,MAAM,UAAU,kLAYN,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC;AAEjD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,CAItD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CAmErD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAO1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEtD;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW;AACrB,8CAA8C;AAC5C,oBAAoB;AACtB,8CAA8C;GAC5C,iBAAiB;AACnB,uEAAuE;GACrE,eAAe;AACjB,wDAAwD;GACtD,gBAAgB;AAClB;kDACkD;GAChD,YAAY;AACd,kEAAkE;GAChE,WAAW,CAAC;AAEhB;2DAC2D;AAC3D,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAK7D;AAmBD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,CAsB1D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiBpD"}

package/dist/oom-classify.js

@@ -125,11 +125,12 @@ export function classifyMessage(msg) {
     // Subrequest cap (Cloudflare platform)
     if (m.includes('too many subrequests'))
         return 'subrequest_cap';
-    // Worker Loader concurrency cap (Cloudflare platform): a Durable Object
-    // admits ~5-6 concurrent dynamic workers, and loader-cache entries are
-    // never released — every distinct loader.get(id) permanently consumes a
-    // slot, so this cap recurs until the DO itself is replaced.
-    if (m.includes('too many concurrent dynamic workers'))
+    // Dynamic Worker concurrency limit (Cloudflare platform): a Durable Object
+    // may have a fixed number of distinct Dynamic Workers with in-flight
+    // requests at once (fabric budgets.ts, DO_DYNAMIC_WORKER_LIMIT). Production
+    // words it "Dynamic worker concurrency limit exceeded: each request may
+    // have up to 10 concurrent dynamic worker invocations. …".
+    if (m.includes('dynamic worker concurrency limit exceeded'))
         return 'dynamic_worker_cap';
     // Memory exhaustion. workerd trace outcome `exceededMemory`; in-band it
     // arrives as a `broken.exceededMemory` actor break, a "…exceeded [its]
@@ -311,7 +312,8 @@ export function describeError(input) {
     const suffix = cause !== 'unknown' ? ` [${cause}]`
         : isTransientDoReset(input) ? ' [transient-do-reset]'
             : isDoOverloaded(input) ? ' [do-overloaded]'
-                : '';
+                : classifyDoCall(input) === 'retryable_flag' ? ' [retryable]'
+                    : '';
     return `${name}${message}${suffix}`;
 }
 function readMessage(input) {

package/dist/tracing.d.ts

@@ -0,0 +1,65 @@
+/**
+ * tracing.ts — Workers custom spans, for modules that cannot import
+ * `cloudflare:workers`, as best-effort telemetry that never changes an
+ * outcome.
+ *
+ * The span API is `tracing` from `cloudflare:workers`
+ * (https://developers.cloudflare.com/workers/observability/traces/custom-spans/):
+ * `enterSpan(name, callback)` runs the callback in a span that is the active
+ * parent of every span and platform call made inside it — automatic RPC
+ * spans included — and ends it when the callback returns or its promise
+ * settles. A span records nothing unless the invocation was head-sampled
+ * (`observability.traces.head_sampling_rate`).
+ *
+ * `setAttributes` and `recordException` shipped on 2026-09-25
+ * (https://developers.cloudflare.com/changelog/post/2026-09-25-custom-span-apis/);
+ * a runtime from before then has `isTraced` and `setAttribute` only. So the
+ * code being traced never touches the runtime's span. It gets a
+ * {@link SpanRecorder}, which records only while the span is traced, uses
+ * whichever methods the runtime has, and swallows anything a span method
+ * throws.
+ *
+ * Core and fabric stay importable outside workerd, so they reach the API
+ * through this leaf: the Worker's composition root hands it over once, at
+ * module scope, with {@link adoptTracing}, exactly as it does `ctx.exports`
+ * (./composition.ts). With nothing adopted — unit tests, an embedder that
+ * never adopts — {@link traced} runs its callback with {@link untraced}.
+ */
+/** Attribute values a span holds; `undefined` entries are ignored. */
+export type SpanAttributes = Record<string, string | number | boolean | undefined>;
+/** The runtime's `Span`, as any Workers runtime with `tracing` may have it. */
+export interface RuntimeSpan {
+    readonly isTraced: boolean;
+    setAttribute?(key: string, value?: string | number | boolean): unknown;
+    setAttributes?(attributes: SpanAttributes): unknown;
+    recordException?(exception: string | {
+        code?: string | number;
+        name?: string;
+        message?: string;
+        stack?: string;
+    }): void;
+}
+/** The part of `cloudflare:workers`'s `tracing` Nimbus uses. */
+export interface Tracer {
+    enterSpan<T>(name: string, callback: (span: RuntimeSpan) => T): T;
+}
+/** What traced code records on its span. Never throws; records nothing unless the span is traced. */
+export interface SpanRecorder {
+    set(attributes: SpanAttributes): void;
+    /**
+     * Record `error` as an exception event. `code`, when given, replaces the
+     * error's own; `context` is prefixed to its message.
+     */
+    exception(error: unknown, code?: string, context?: string): void;
+}
+/** The recorder of a span that is not traced, or of no span at all. */
+export declare const untraced: SpanRecorder;
+/** Hand this isolate's `tracing` over. The first adoption stands, like `adoptCtxExports`. */
+export declare function adoptTracing(value: Tracer): void;
+/**
+ * Run `fn` in a span named `name` carrying `attributes`, and record on it the
+ * exception `fn` throws or its promise rejects with. What `fn` returns or
+ * throws reaches the caller unchanged, whatever the span does.
+ */
+export declare function traced<T>(name: string, attributes: SpanAttributes, fn: (span: SpanRecorder) => T): T;
+//# sourceMappingURL=tracing.d.ts.map

package/dist/tracing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracing.d.ts","sourceRoot":"","sources":["../src/tracing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,sEAAsE;AACtE,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;AAEnF,+EAA+E;AAC/E,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACvE,aAAa,CAAC,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC;IACpD,eAAe,CAAC,CACd,SAAS,EAAE,MAAM,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9F,IAAI,CAAC;CACT;AAED,gEAAgE;AAChE,MAAM,WAAW,MAAM;IACrB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,CAAC,GAAG,CAAC,CAAC;CACnE;AAED,qGAAqG;AACrG,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClE;AAED,uEAAuE;AACvE,eAAO,MAAM,QAAQ,EAAE,YAA0D,CAAC;AAIlF,6FAA6F;AAC7F,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhD;AAyCD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,EAAE,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,CAAC,GAAG,CAAC,CAkBpG"}