@nimbus-sh/platform 0.5.0 → 0.6.0

package/dist/composition.d.ts

@@ -11,8 +11,18 @@
  *     stagedBootAssembler: (env, stage) => assembleConfig(env, stage),
  *   });
  *
- * First-write-wins, like every holder in this module: the composition
- * root's module scope runs once per isolate, before any request.
+ * The composition belongs at module scope: it is per isolate, and the
+ * platform serves a worker's entrypoints from whichever isolate it likes,
+ * so an isolate that never ran an embedder's request path must still know
+ * the composition. Composing again with the same values is a no-op;
+ * composing again with different values throws, because the second caller
+ * would otherwise run against a host it never named (a Worker that imports
+ * Nimbus's own entry and composes its own host would be that caller).
+ *
+ * The one thing the entrypoints need from the composition, the route back
+ * to the host, travels with every binding the fabric mints
+ * ({@link hostRoute}), so an entrypoint answers correctly in an isolate
+ * whose composition is absent or different.
  *
  * `ctx.exports` is runtime state, not composition: workerd mints it per
  * instance, so the embedder captures it where the platform hands it over —
@@ -36,15 +46,41 @@ export interface FabricComposition {
     /** RPC method the host forwards to workspace.supervisorOp. */
     hostDispatchMethod?: string;
 }
+/**
+ * The way back to the host from a binding the fabric minted: the namespace
+ * binding the host's Durable Object lives under, the method it forwards
+ * supervisor envelopes through, and the entrypoint export that answers
+ * supervisor bindings. Minted from the composition in the host's isolate
+ * and carried in the binding's props, so the entrypoint that receives the
+ * call resolves the host from the props rather than from its own isolate's
+ * composition.
+ */
+export interface HostRoute {
+    supervisorEntrypoint: string;
+    hostNamespace: string;
+    hostDispatchMethod: string;
+}
 export declare const DEFAULT_HOST_NAMESPACE = "NIMBUS_SESSION";
 export declare const DEFAULT_HOST_DISPATCH_METHOD = "supervisorOp";
-/** Composition and loopback exports are first-write-wins for this isolate. */
+/**
+ * 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.
+ */
 export declare function composeFabric(value: FabricComposition): void;
 export declare function adoptCtxExports(value: CtxExports): void;
 export declare function getCtxExports(): CtxExports | null;
-export declare function supervisorEntrypoint(exportsObj?: unknown): EntrypointLoopbackFactory | null;
+export declare function supervisorEntrypoint(exportsObj?: unknown, name?: string | undefined): EntrypointLoopbackFactory | null;
 export declare function supervisorEntrypointName(): string | null;
 export declare function hostNamespace(): string;
 export declare function hostDispatchMethod(): string;
+/**
+ * The composed route, for the props of a binding minted in this isolate.
+ * Null when nothing is composed, like {@link supervisorEntrypoint}: a
+ * program run without a composition gets no supervisor binding, and needs
+ * no route back to a host it cannot reach.
+ */
+export declare function hostRoute(): HostRoute | null;
 export declare function stagedBootAssembler(): StagedBootAssembler;
 //# sourceMappingURL=composition.d.ts.map

package/dist/composition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../src/composition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;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,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AACvD,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAI3D,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAE5D;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,GAAG,yBAAyB,GAAG,IAAI,CAO3F;AAED,wBAAgB,wBAAwB,IAAI,MAAM,GAAG,IAAI,CAExD;AAED,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;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;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"}

package/dist/composition.js

@@ -2,10 +2,30 @@ export const DEFAULT_HOST_NAMESPACE = 'NIMBUS_SESSION';
 export const DEFAULT_HOST_DISPATCH_METHOD = 'supervisorOp';
 let composition = null;
 let ctxExports = null;
-/** Composition and loopback exports are first-write-wins for this isolate. */
+/**
+ * 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.
+ */
 export function composeFabric(value) {
-    if (!composition)
+    if (!composition) {
         composition = value;
+        return;
+    }
+    const differences = ['supervisorEntrypoint', 'hostNamespace', 'hostDispatchMethod', 'stagedBootAssembler']
+        .filter((key) => composition?.[key] !== value[key]);
+    if (differences.length === 0)
+        return;
+    const describe = (c) => JSON.stringify({
+        supervisorEntrypoint: c.supervisorEntrypoint,
+        hostNamespace: c.hostNamespace ?? DEFAULT_HOST_NAMESPACE,
+        hostDispatchMethod: c.hostDispatchMethod ?? DEFAULT_HOST_DISPATCH_METHOD,
+        stagedBootAssembler: c.stagedBootAssembler ? 'set' : 'unset',
+    });
+    throw new Error(`fabric: composed twice with different values (${differences.join(', ')}): `
+        + `first ${describe(composition)}, then ${describe(value)}. `
+        + 'One composition per isolate; a Worker that imports another Nimbus entry inherits its composition.');
 }
 export function adoptCtxExports(value) {
     if (!ctxExports)
@@ -14,9 +34,8 @@ export function adoptCtxExports(value) {
 export function getCtxExports() {
     return ctxExports;
 }
-export function supervisorEntrypoint(exportsObj) {
+export function supervisorEntrypoint(exportsObj, name = composition?.supervisorEntrypoint) {
     const exports = exportsObj ?? ctxExports;
-    const name = composition?.supervisorEntrypoint;
     if (!name)
         return null;
     if ((typeof exports !== 'object' && typeof exports !== 'function') || exports === null)
@@ -33,6 +52,21 @@ export function hostNamespace() {
 export function hostDispatchMethod() {
     return composition?.hostDispatchMethod ?? DEFAULT_HOST_DISPATCH_METHOD;
 }
+/**
+ * The composed route, for the props of a binding minted in this isolate.
+ * Null when nothing is composed, like {@link supervisorEntrypoint}: a
+ * program run without a composition gets no supervisor binding, and needs
+ * no route back to a host it cannot reach.
+ */
+export function hostRoute() {
+    if (!composition)
+        return null;
+    return {
+        supervisorEntrypoint: composition.supervisorEntrypoint,
+        hostNamespace: hostNamespace(),
+        hostDispatchMethod: hostDispatchMethod(),
+    };
+}
 export function stagedBootAssembler() {
     const assembler = composition?.stagedBootAssembler;
     if (!assembler) {

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,6 +75,12 @@ 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
@@ -175,6 +181,8 @@ 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,6 +23,7 @@ const _counters = {
     inFlightRpcPayloadBytes: 0,
     prefetchBundleBytes: 0,
     prefetchCacheBytes: 0,
+    transformCacheBytes: 0,
     installFacet: {
         tarballsCompleted: 0,
         cumulativeBytesDecoded: 0,
@@ -122,6 +123,11 @@ 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,6 +180,12 @@ 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,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"}
+{"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"}

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,6 +160,7 @@ 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 +
@@ -169,6 +170,7 @@ 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/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
@@ -69,6 +70,28 @@ export declare const SQLITE_MAX_ROW_BYTES = 2000000;
  * fabric defers async reconciliation off the gate entirely (`onColdStart`).
  */
 export declare const BLOCK_CONCURRENCY_CANCEL_MS = 30000;
+/**
+ * Cadence of the alarm that keeps a session Durable Object in memory while
+ * a resident process runs. The platform evicts an object after roughly ten
+ * seconds with no in-flight event; a pending promise (`ctx.waitUntil`) is
+ * not one, and facets die with their parent. Measured 2026-09-21 on local
+ * workerd and on Cloudflare: a quiet resident process survived 8 s of
+ * silence and was re-driven under a new pid namespace after 12 s.
+ */
+export declare const RESIDENT_KEEPALIVE_MS = 5000;
+/**
+ * How long the keep-alive holds a session after its last client is gone.
+ *
+ * The keep-alive exists so a quiet process survives while its user is
+ * present. Unbounded, it made every abandoned session with a dev server
+ * run forever: the probe suite's cancelled runs left staging with resident
+ * watchers polling `stat` at ~7.5/s in the isolate every session shares,
+ * and launches that pass on a fresh Worker reset there (2026-09-22). Past
+ * this grace with no attached socket and no request, the session idles
+ * out as it did before the keep-alive, and the launch journal re-drives
+ * the process when a client returns. Long enough for a tab reload.
+ */
+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,
@@ -81,7 +104,9 @@ export declare const BLOCK_CONCURRENCY_CANCEL_MS = 30000;
  */
 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;;;;;;;;;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
@@ -77,6 +82,29 @@ export const SQLITE_MAX_ROW_BYTES = 2_000_000;
  * fabric defers async reconciliation off the gate entirely (`onColdStart`).
  */
 export const BLOCK_CONCURRENCY_CANCEL_MS = 30_000;
+// ── Eviction window ─────────────────────────────────────────────────────
+/**
+ * Cadence of the alarm that keeps a session Durable Object in memory while
+ * a resident process runs. The platform evicts an object after roughly ten
+ * seconds with no in-flight event; a pending promise (`ctx.waitUntil`) is
+ * not one, and facets die with their parent. Measured 2026-09-21 on local
+ * workerd and on Cloudflare: a quiet resident process survived 8 s of
+ * silence and was re-driven under a new pid namespace after 12 s.
+ */
+export const RESIDENT_KEEPALIVE_MS = 5_000;
+/**
+ * How long the keep-alive holds a session after its last client is gone.
+ *
+ * The keep-alive exists so a quiet process survives while its user is
+ * present. Unbounded, it made every abandoned session with a dev server
+ * run forever: the probe suite's cancelled runs left staging with resident
+ * watchers polling `stat` at ~7.5/s in the isolate every session shares,
+ * and launches that pass on a fresh Worker reset there (2026-09-22). Past
+ * this grace with no attached socket and no request, the session idles
+ * out as it did before the keep-alive, and the launch journal re-drives
+ * the process when a client returns. Long enough for a tab reload.
+ */
+export const RESIDENT_KEEPALIVE_DETACHED_MS = 60_000;
 // ── WebSocket attachment bound ──────────────────────────────────────────
 /**
  * Bytes one hibernatable WebSocket attachment may serialize to. Verified in
@@ -94,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:
@@ -122,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,7 +1,7 @@
 {
   "name": "@nimbus-sh/platform",
-  "version": "0.5.0",
-  "description": "The measured Cloudflare platform truths Nimbus is built on — error taxonomy, limits tables, budget coordination, and wire-format primitives, with zero runtime dependencies.",
+  "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",
     "workers",
@@ -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/composition.ts

@@ -11,8 +11,18 @@
  *     stagedBootAssembler: (env, stage) => assembleConfig(env, stage),
  *   });
  *
- * First-write-wins, like every holder in this module: the composition
- * root's module scope runs once per isolate, before any request.
+ * The composition belongs at module scope: it is per isolate, and the
+ * platform serves a worker's entrypoints from whichever isolate it likes,
+ * so an isolate that never ran an embedder's request path must still know
+ * the composition. Composing again with the same values is a no-op;
+ * composing again with different values throws, because the second caller
+ * would otherwise run against a host it never named (a Worker that imports
+ * Nimbus's own entry and composes its own host would be that caller).
+ *
+ * The one thing the entrypoints need from the composition, the route back
+ * to the host, travels with every binding the fabric mints
+ * ({@link hostRoute}), so an entrypoint answers correctly in an isolate
+ * whose composition is absent or different.
  *
  * `ctx.exports` is runtime state, not composition: workerd mints it per
  * instance, so the embedder captures it where the platform hands it over —
@@ -36,14 +46,51 @@ export interface FabricComposition {
   hostDispatchMethod?: string;
 }
 
+/**
+ * The way back to the host from a binding the fabric minted: the namespace
+ * binding the host's Durable Object lives under, the method it forwards
+ * supervisor envelopes through, and the entrypoint export that answers
+ * supervisor bindings. Minted from the composition in the host's isolate
+ * and carried in the binding's props, so the entrypoint that receives the
+ * call resolves the host from the props rather than from its own isolate's
+ * composition.
+ */
+export interface HostRoute {
+  supervisorEntrypoint: string;
+  hostNamespace: string;
+  hostDispatchMethod: string;
+}
+
 export const DEFAULT_HOST_NAMESPACE = 'NIMBUS_SESSION';
 export const DEFAULT_HOST_DISPATCH_METHOD = 'supervisorOp';
 let composition: FabricComposition | null = null;
 let ctxExports: CtxExports | null = null;
 
-/** Composition and loopback exports are first-write-wins for this isolate. */
+/**
+ * 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.
+ */
 export function composeFabric(value: FabricComposition): void {
-  if (!composition) composition = value;
+  if (!composition) {
+    composition = value;
+    return;
+  }
+  const differences = (['supervisorEntrypoint', 'hostNamespace', 'hostDispatchMethod', 'stagedBootAssembler'] as const)
+    .filter((key) => composition?.[key] !== value[key]);
+  if (differences.length === 0) return;
+  const describe = (c: FabricComposition) => JSON.stringify({
+    supervisorEntrypoint: c.supervisorEntrypoint,
+    hostNamespace: c.hostNamespace ?? DEFAULT_HOST_NAMESPACE,
+    hostDispatchMethod: c.hostDispatchMethod ?? DEFAULT_HOST_DISPATCH_METHOD,
+    stagedBootAssembler: c.stagedBootAssembler ? 'set' : 'unset',
+  });
+  throw new Error(
+    `fabric: composed twice with different values (${differences.join(', ')}): `
+      + `first ${describe(composition)}, then ${describe(value)}. `
+      + 'One composition per isolate; a Worker that imports another Nimbus entry inherits its composition.',
+  );
 }
 
 export function adoptCtxExports(value: CtxExports): void {
@@ -54,9 +101,8 @@ export function getCtxExports(): CtxExports | null {
   return ctxExports;
 }
 
-export function supervisorEntrypoint(exportsObj?: unknown): EntrypointLoopbackFactory | null {
+export function supervisorEntrypoint(exportsObj?: unknown, name = composition?.supervisorEntrypoint): EntrypointLoopbackFactory | null {
   const exports = exportsObj ?? ctxExports;
-  const name = composition?.supervisorEntrypoint;
   if (!name) return null;
   if ((typeof exports !== 'object' && typeof exports !== 'function') || exports === null) return null;
   const factory = (exports as Record<string, unknown>)[name];
@@ -75,6 +121,21 @@ export function hostDispatchMethod(): string {
   return composition?.hostDispatchMethod ?? DEFAULT_HOST_DISPATCH_METHOD;
 }
 
+/**
+ * The composed route, for the props of a binding minted in this isolate.
+ * Null when nothing is composed, like {@link supervisorEntrypoint}: a
+ * program run without a composition gets no supervisor binding, and needs
+ * no route back to a host it cannot reach.
+ */
+export function hostRoute(): HostRoute | null {
+  if (!composition) return null;
+  return {
+    supervisorEntrypoint: composition.supervisorEntrypoint,
+    hostNamespace: hostNamespace(),
+    hostDispatchMethod: hostDispatchMethod(),
+  };
+}
+
 export function stagedBootAssembler(): StagedBootAssembler {
   const assembler = composition?.stagedBootAssembler;
   if (!assembler) {

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/diag-counters.ts

@@ -82,6 +82,12 @@ 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
@@ -141,6 +147,7 @@ const _counters: DiagCounters = {
   inFlightRpcPayloadBytes: 0,
   prefetchBundleBytes: 0,
   prefetchCacheBytes: 0,
+  transformCacheBytes: 0,
   installFacet: {
     tarballsCompleted: 0,
     cumulativeBytesDecoded: 0,
@@ -243,6 +250,12 @@ export function setPrefetchCacheBytes(bytes: number): void {
   _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: number): void {
+  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/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'.
  *
@@ -200,6 +200,12 @@ 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
@@ -297,6 +303,7 @@ export function estimateSupervisorHeap(
     streamingBuffersBytes: c.inFlightRpcPayloadBytes,
     prefetchBundleBytes: c.prefetchBundleBytes,
     prefetchCacheBytes: c.prefetchCacheBytes,
+    transformCacheBytes: c.transformCacheBytes,
     unattributedReservationBytes: Math.max(
       0,
       allocationBudget.current - transientAttributedBytes,
@@ -311,6 +318,7 @@ export function estimateSupervisorHeap(
     breakdown.streamingBuffersBytes +
     breakdown.prefetchBundleBytes +
     breakdown.prefetchCacheBytes +
+    breakdown.transformCacheBytes +
     breakdown.unattributedReservationBytes;
 
   const percentOfCeiling = Math.round(

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
@@ -89,6 +95,32 @@ export const SQLITE_MAX_ROW_BYTES = 2_000_000;
  */
 export const BLOCK_CONCURRENCY_CANCEL_MS = 30_000;
 
+// ── Eviction window ─────────────────────────────────────────────────────
+
+/**
+ * Cadence of the alarm that keeps a session Durable Object in memory while
+ * a resident process runs. The platform evicts an object after roughly ten
+ * seconds with no in-flight event; a pending promise (`ctx.waitUntil`) is
+ * not one, and facets die with their parent. Measured 2026-09-21 on local
+ * workerd and on Cloudflare: a quiet resident process survived 8 s of
+ * silence and was re-driven under a new pid namespace after 12 s.
+ */
+export const RESIDENT_KEEPALIVE_MS = 5_000;
+
+/**
+ * How long the keep-alive holds a session after its last client is gone.
+ *
+ * The keep-alive exists so a quiet process survives while its user is
+ * present. Unbounded, it made every abandoned session with a dev server
+ * run forever: the probe suite's cancelled runs left staging with resident
+ * watchers polling `stat` at ~7.5/s in the isolate every session shares,
+ * and launches that pass on a fresh Worker reset there (2026-09-22). Past
+ * this grace with no attached socket and no request, the session idles
+ * out as it did before the keep-alive, and the launch journal re-drives
+ * the process when a client returns. Long enough for a tab reload.
+ */
+export const RESIDENT_KEEPALIVE_DETACHED_MS = 60_000;
+
 // ── WebSocket attachment bound ──────────────────────────────────────────
 
 /**
@@ -110,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:
@@ -139,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() {} };
 }