@nimbus-sh/platform 0.5.1 → 0.6.0

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/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'.
  *

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'.
  *

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
@@ -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
@@ -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,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,CAiBpD"}

package/dist/oom-classify.js

@@ -311,7 +311,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/w7-frame.d.ts.map

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

package/dist/w7-frame.js

@@ -2,6 +2,7 @@
  * W7 v3 — incremental typed records for streamed bulk filesystem writes.
  * The format is internal: every producer and consumer deploys together.
  */
+import { crc32 } from './crc32.js';
 import { CHUNK_SIZE } from './limits.js';
 export const W7_MAGIC = new Uint8Array([0x4e, 0x57, 0x37, 0x03]);
 const ENCODER_QUEUE_HWM = 0;
@@ -101,7 +102,7 @@ export async function decodeWriteBatchStream(stream, options = {}) {
         }
         const beginPayload = await buffer.readExact(beginEnvelope.length, 'batch-begin payload');
         const begin = parseBatchBegin(beginPayload);
-        const initialCheck = updateRecordCheck(CRC_SEED, beginEnvelope.header, beginPayload);
+        const initialCheck = updateRecordCheck(0, beginEnvelope.header, beginPayload);
         handedOff = true;
         return {
             batchId: begin.id,
@@ -180,7 +181,7 @@ async function* decodeRecords(stream, reader, buffer, options, initialCheck) {
                     throwIfAborted(options.signal);
                     const data = await buffer.readExact(dataLength, 'file-chunk data');
                     batchCheck = updateRecordCheck(batchCheck, envelope.header, headerPayload, data);
-                    active.check = crc32Update(active.check, data);
+                    active.check = crc32(data, active.check);
                     active.nextChunkId++;
                     active.receivedBytes += dataLength;
                     summary.recordCount++;
@@ -242,7 +243,7 @@ async function* decodeRecords(stream, reader, buffer, options, initialCheck) {
                         inode,
                         nextChunkId: 0,
                         receivedBytes: 0,
-                        check: CRC_SEED,
+                        check: 0,
                     };
                     yield { type: 'file-begin', streamContentId: metadata.contentId, inode };
                     break;
@@ -251,7 +252,7 @@ async function* decodeRecords(stream, reader, buffer, options, initialCheck) {
                     if (!active)
                         throw new Error('w7-frame: file-end without active file');
                     const metadata = parseFileEnd(payload);
-                    const actualCheck = crc32Finish(active.check);
+                    const actualCheck = active.check;
                     if (metadata.contentId !== active.metadata.contentId) {
                         throw new Error(`w7-frame: file-end content id mismatch for ${active.inode.path}`);
                     }
@@ -281,7 +282,7 @@ async function* decodeRecords(stream, reader, buffer, options, initialCheck) {
                     if (active)
                         throw new Error(`w7-frame: batch-end while file ${active.inode.path} is active`);
                     const actual = parseBatchEnd(payload);
-                    const expected = { ...summary, check: crc32Finish(batchCheck) };
+                    const expected = { ...summary, check: batchCheck };
                     if (!sameSummary(actual, expected)) {
                         throw new Error(`w7-frame: batch-end summary mismatch; expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
                     }
@@ -315,7 +316,7 @@ async function* decodeRecords(stream, reader, buffer, options, initialCheck) {
 }
 function* encodeRecords(batchId, deletes, directories, files) {
     const state = {
-        batchCheck: CRC_SEED,
+        batchCheck: 0,
         summary: {
             recordCount: 0,
             pathCount: 0,
@@ -350,7 +351,7 @@ function* encodeRecords(batchId, deletes, directories, files) {
             size: file.inode.size,
             chunkCount: file.inode.chunkCount,
         }, state);
-        let fileCheck = CRC_SEED;
+        let fileCheck = 0;
         for (const chunk of file.chunks) {
             const data = chunk.data;
             const contentBytes = new TextEncoder().encode(file.contentId);
@@ -364,19 +365,19 @@ function* encodeRecords(batchId, deletes, directories, files) {
             state.summary.recordCount++;
             state.summary.chunkCount++;
             state.summary.byteCount += data.byteLength;
-            fileCheck = crc32Update(fileCheck, data);
+            fileCheck = crc32(data, fileCheck);
             yield [concatBytes(header, prefix), data];
         }
         yield encodeMetadataRecord(RecordTag.FileEnd, {
             contentId: file.contentId,
             size: file.inode.size,
             chunkCount: file.inode.chunkCount,
-            check: crc32Finish(fileCheck),
+            check: fileCheck,
         }, state);
     }
     const end = {
         ...state.summary,
-        check: crc32Finish(state.batchCheck),
+        check: state.batchCheck,
     };
     yield encodeMetadataRecord(RecordTag.BatchEnd, end);
 }
@@ -718,33 +719,9 @@ function readU32LE(bytes, offset) {
 function updateRecordCheck(seed, ...parts) {
     let check = seed;
     for (const part of parts)
-        check = crc32Update(check, part);
+        check = crc32(part, check);
     return check;
 }
-const CRC_SEED = 0xffff_ffff;
-let crcTable = null;
-function crc32Update(check, bytes) {
-    crcTable ??= createCrcTable();
-    const table = crcTable;
-    let value = check;
-    for (const byte of bytes)
-        value = table[(value ^ byte) & 0xff] ^ (value >>> 8);
-    return value >>> 0;
-}
-function crc32Finish(check) {
-    return (check ^ 0xffff_ffff) >>> 0;
-}
-function createCrcTable() {
-    const table = new Uint32Array(256);
-    for (let index = 0; index < table.length; index++) {
-        let value = index;
-        for (let bit = 0; bit < 8; bit++) {
-            value = (value & 1) !== 0 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
-        }
-        table[index] = value >>> 0;
-    }
-    return table;
-}
 function noopRetention(bytes) {
     return { bytes, release() { } };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/platform",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "The measured Cloudflare platform truths Nimbus is built on \u2014 error taxonomy, limits tables, budget coordination, and wire-format primitives, with zero runtime dependencies.",
   "keywords": [
     "cloudflare",
@@ -43,8 +43,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json --noCheck --noEmit false --declaration true --declarationMap true --outDir dist --rootDir src",
-    "prepack": "npm run build",
+    "build": "node ../../scripts/clean-dist.mjs && tsc -p tsconfig.json --noCheck --noEmit false --declaration true --declarationMap true --outDir dist --rootDir src",
+    "prepublishOnly": "bun ../../scripts/dist-integrity.mjs --publish",
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {

package/src/crc32.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+
+type NodeZlib = { crc32?(data: Uint8Array, value?: number): number };
+type BuiltinModules = { process?: { getBuiltinModule?(id: 'node:zlib'): NodeZlib | undefined } };
+
+/** 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 as BuiltinModules).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: Uint32Array | null = null;
+
+function createCrcTables(): Uint32Array {
+  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: Uint8Array, previous = 0): number {
+  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/src/heap-estimate.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'.
  *

package/src/limits.ts

@@ -52,6 +52,12 @@ export const SQL_MAX_BOUND_PARAMETERS = 100;
  */
 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
@@ -136,6 +142,25 @@ export const WS_ATTACHMENT_LIMIT_BYTES = 16_384;
 // 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:
@@ -165,6 +190,12 @@ export const MAX_RPC_SAFE_PAYLOAD_BYTES = 28 * 1024 * 1024;
 // 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/src/oom-classify.ts

@@ -224,7 +224,7 @@ export 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
@@ -329,6 +329,7 @@ export function describeError(input: unknown): string {
   const suffix = cause !== 'unknown' ? ` [${cause}]`
     : isTransientDoReset(input) ? ' [transient-do-reset]'
     : isDoOverloaded(input) ? ' [do-overloaded]'
+    : classifyDoCall(input) === 'retryable_flag' ? ' [retryable]'
     : '';
   return `${name}${message}${suffix}`;
 }

package/src/w7-frame.ts

@@ -3,6 +3,7 @@
  * The format is internal: every producer and consumer deploys together.
  */
 
+import { crc32 } from './crc32.js';
 import { CHUNK_SIZE } from './limits.js';
 
 // The batch payload types live WITH the wire format that encodes them: every
@@ -246,7 +247,7 @@ export async function decodeWriteBatchStream(
     }
     const beginPayload = await buffer.readExact(beginEnvelope.length, 'batch-begin payload');
     const begin = parseBatchBegin(beginPayload);
-    const initialCheck = updateRecordCheck(CRC_SEED, beginEnvelope.header, beginPayload);
+    const initialCheck = updateRecordCheck(0, beginEnvelope.header, beginPayload);
     handedOff = true;
     return {
       batchId: begin.id,
@@ -343,7 +344,7 @@ async function* decodeRecords(
           throwIfAborted(options.signal);
           const data = await buffer.readExact(dataLength, 'file-chunk data');
           batchCheck = updateRecordCheck(batchCheck, envelope.header, headerPayload, data);
-          active.check = crc32Update(active.check, data);
+          active.check = crc32(data, active.check);
           active.nextChunkId++;
           active.receivedBytes += dataLength;
           summary.recordCount++;
@@ -406,7 +407,7 @@ async function* decodeRecords(
             inode,
             nextChunkId: 0,
             receivedBytes: 0,
-            check: CRC_SEED,
+            check: 0,
           };
           yield { type: 'file-begin', streamContentId: metadata.contentId, inode };
           break;
@@ -414,7 +415,7 @@ async function* decodeRecords(
         case RecordTag.FileEnd: {
           if (!active) throw new Error('w7-frame: file-end without active file');
           const metadata = parseFileEnd(payload);
-          const actualCheck = crc32Finish(active.check);
+          const actualCheck = active.check;
           if (metadata.contentId !== active.metadata.contentId) {
             throw new Error(`w7-frame: file-end content id mismatch for ${active.inode.path}`);
           }
@@ -443,7 +444,7 @@ async function* decodeRecords(
         case RecordTag.BatchEnd: {
           if (active) throw new Error(`w7-frame: batch-end while file ${active.inode.path} is active`);
           const actual = parseBatchEnd(payload);
-          const expected = { ...summary, check: crc32Finish(batchCheck) };
+          const expected = { ...summary, check: batchCheck };
           if (!sameSummary(actual, expected)) {
             throw new Error(
               `w7-frame: batch-end summary mismatch; expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
@@ -479,7 +480,7 @@ function* encodeRecords(
   files: EncoderFile[],
 ): Generator<Uint8Array[]> {
   const state: EncoderState = {
-    batchCheck: CRC_SEED,
+    batchCheck: 0,
     summary: {
       recordCount: 0,
       pathCount: 0,
@@ -514,7 +515,7 @@ function* encodeRecords(
       size: file.inode.size,
       chunkCount: file.inode.chunkCount,
     }, state);
-    let fileCheck = CRC_SEED;
+    let fileCheck = 0;
     for (const chunk of file.chunks) {
       const data = chunk.data;
       const contentBytes = new TextEncoder().encode(file.contentId);
@@ -528,19 +529,19 @@ function* encodeRecords(
       state.summary.recordCount++;
       state.summary.chunkCount++;
       state.summary.byteCount += data.byteLength;
-      fileCheck = crc32Update(fileCheck, data);
+      fileCheck = crc32(data, fileCheck);
       yield [concatBytes(header, prefix), data];
     }
     yield encodeMetadataRecord(RecordTag.FileEnd, {
       contentId: file.contentId,
       size: file.inode.size,
       chunkCount: file.inode.chunkCount,
-      check: crc32Finish(fileCheck),
+      check: fileCheck,
     }, state);
   }
   const end: W7BatchSummary = {
     ...state.summary,
-    check: crc32Finish(state.batchCheck),
+    check: state.batchCheck,
   };
   yield encodeMetadataRecord(RecordTag.BatchEnd, end);
 }
@@ -916,37 +917,10 @@ function readU32LE(bytes: Uint8Array, offset: number): number {
 
 function updateRecordCheck(seed: number, ...parts: Uint8Array[]): number {
   let check = seed;
-  for (const part of parts) check = crc32Update(check, part);
+  for (const part of parts) check = crc32(part, check);
   return check;
 }
 
-const CRC_SEED = 0xffff_ffff;
-let crcTable: Uint32Array | null = null;
-
-function crc32Update(check: number, bytes: Uint8Array): number {
-  crcTable ??= createCrcTable();
-  const table = crcTable;
-  let value = check;
-  for (const byte of bytes) value = table[(value ^ byte) & 0xff] ^ (value >>> 8);
-  return value >>> 0;
-}
-
-function crc32Finish(check: number): number {
-  return (check ^ 0xffff_ffff) >>> 0;
-}
-
-function createCrcTable(): Uint32Array {
-  const table = new Uint32Array(256);
-  for (let index = 0; index < table.length; index++) {
-    let value = index;
-    for (let bit = 0; bit < 8; bit++) {
-      value = (value & 1) !== 0 ? 0xedb8_8320 ^ (value >>> 1) : value >>> 1;
-    }
-    table[index] = value >>> 0;
-  }
-  return table;
-}
-
 function noopRetention(bytes: number): W7ChunkRetention {
   return { bytes, release() {} };
 }