@nimbus-sh/platform 0.5.1 → 0.7.0

package/dist/tracing.js

@@ -0,0 +1,107 @@
+/**
+ * tracing.ts — Workers custom spans, for modules that cannot import
+ * `cloudflare:workers`, as best-effort telemetry that never changes an
+ * outcome.
+ *
+ * The span API is `tracing` from `cloudflare:workers`
+ * (https://developers.cloudflare.com/workers/observability/traces/custom-spans/):
+ * `enterSpan(name, callback)` runs the callback in a span that is the active
+ * parent of every span and platform call made inside it — automatic RPC
+ * spans included — and ends it when the callback returns or its promise
+ * settles. A span records nothing unless the invocation was head-sampled
+ * (`observability.traces.head_sampling_rate`).
+ *
+ * `setAttributes` and `recordException` shipped on 2026-09-25
+ * (https://developers.cloudflare.com/changelog/post/2026-09-25-custom-span-apis/);
+ * a runtime from before then has `isTraced` and `setAttribute` only. So the
+ * code being traced never touches the runtime's span. It gets a
+ * {@link SpanRecorder}, which records only while the span is traced, uses
+ * whichever methods the runtime has, and swallows anything a span method
+ * throws.
+ *
+ * Core and fabric stay importable outside workerd, so they reach the API
+ * through this leaf: the Worker's composition root hands it over once, at
+ * module scope, with {@link adoptTracing}, exactly as it does `ctx.exports`
+ * (./composition.ts). With nothing adopted — unit tests, an embedder that
+ * never adopts — {@link traced} runs its callback with {@link untraced}.
+ */
+/** The recorder of a span that is not traced, or of no span at all. */
+export const untraced = Object.freeze({ set() { }, exception() { } });
+let tracer = null;
+/** Hand this isolate's `tracing` over. The first adoption stands, like `adoptCtxExports`. */
+export function adoptTracing(value) {
+    tracer ??= value;
+}
+function recorderFor(span) {
+    try {
+        if (!span.isTraced)
+            return untraced;
+    }
+    catch {
+        return untraced;
+    }
+    return {
+        set(attributes) {
+            try {
+                if (typeof span.setAttributes === 'function') {
+                    span.setAttributes(attributes);
+                }
+                else if (typeof span.setAttribute === 'function') {
+                    for (const [key, value] of Object.entries(attributes)) {
+                        if (value !== undefined)
+                            span.setAttribute(key, value);
+                    }
+                }
+            }
+            catch { /* telemetry is best-effort */ }
+        },
+        exception(error, code, context = '') {
+            try {
+                if (typeof span.recordException !== 'function')
+                    return;
+                if (error instanceof Error) {
+                    const own = 'code' in error ? error.code : undefined;
+                    span.recordException({
+                        code: code ?? (typeof own === 'string' || typeof own === 'number' ? own : undefined),
+                        name: error.name,
+                        message: context + error.message,
+                        stack: error.stack,
+                    });
+                }
+                else {
+                    span.recordException(code === undefined && !context
+                        ? String(error)
+                        : { code, message: context + String(error) });
+                }
+            }
+            catch { /* telemetry is best-effort */ }
+        },
+    };
+}
+/**
+ * Run `fn` in a span named `name` carrying `attributes`, and record on it the
+ * exception `fn` throws or its promise rejects with. What `fn` returns or
+ * throws reaches the caller unchanged, whatever the span does.
+ */
+export function traced(name, attributes, fn) {
+    if (!tracer)
+        return fn(untraced);
+    return tracer.enterSpan(name, (runtimeSpan) => {
+        const span = recorderFor(runtimeSpan);
+        span.set(attributes);
+        let result;
+        try {
+            result = fn(span);
+        }
+        catch (error) {
+            span.exception(error);
+            throw error;
+        }
+        if (!(result instanceof Promise))
+            return result;
+        return result.catch((error) => {
+            span.exception(error);
+            throw error;
+        });
+    });
+}

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/dist/weighted-credit-pool.d.ts

@@ -9,11 +9,6 @@ export interface WeightedCreditPoolStats {
     readonly current: number;
     readonly peak: number;
     readonly queued: number;
-    /**
-     * Credit held by owners that keep it for their whole lifetime rather than
-     * for one operation — the floor no waiter can ever expect to get back.
-     */
-    readonly resident: number;
 }
 export interface WeightedCreditPoolOptions {
     /**
@@ -61,14 +56,6 @@ export declare class WeightedCreditPool {
     private isSmall;
     tryAcquire(bytes: number): ResizableCreditLease | null;
     acquire(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
-    /**
-     * Take credit that will be held for the owner's whole lifetime rather than
-     * for one operation — the esbuild pool's wasm image is the case.
-     *
-     * Recorded as a floor so a later claim that could never fit around it is
-     * refused with both numbers instead of parking in the FIFO forever.
-     */
-    acquireResident(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
     private validateRequest;
 }
 //# sourceMappingURL=weighted-credit-pool.d.ts.map

package/dist/weighted-credit-pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weighted-credit-pool.d.ts","sourceRoot":"","sources":["../src/weighted-credit-pool.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAmJD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,kBAAkB;IAKjB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAJrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAEtB,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B;IAoB9E,IAAI,KAAK,IAAI,uBAAuB,CAUnC;IAED,OAAO,CAAC,OAAO;IAIf,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAOtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiB3E;;;;;;OAMG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IASnF,OAAO,CAAC,eAAe;CAOxB"}
+{"version":3,"file":"weighted-credit-pool.d.ts","sourceRoot":"","sources":["../src/weighted-credit-pool.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAkHD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,kBAAkB;IAKjB,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAJrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;gBAEtB,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B;IAoB9E,IAAI,KAAK,IAAI,uBAAuB,CASnC;IAED,OAAO,CAAC,OAAO;IAIf,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,GAAG,IAAI;IAOtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiB3E,OAAO,CAAC,eAAe;CAOxB"}

package/dist/weighted-credit-pool.js

@@ -3,52 +3,27 @@ class CreditLane {
     capacity;
     current = 0;
     peak = 0;
-    resident = 0;
     waiters = [];
     constructor(capacity) {
         this.capacity = capacity;
     }
     get stats() {
-        return {
-            current: this.current, peak: this.peak, queued: this.waiters.length, resident: this.resident,
-        };
+        return { current: this.current, peak: this.peak, queued: this.waiters.length };
     }
     tryAcquire(bytes) {
         if (this.waiters.length > 0 || this.current + bytes > this.capacity)
             return null;
-        return this.grant(bytes, false);
+        return this.grant(bytes);
     }
-    /**
-     * The largest claim this lane can ever grant: capacity less what resident
-     * owners hold for their whole lifetime. A claim above it cannot be
-     * satisfied by waiting, because nothing it is waiting for will be
-     * released.
-     */
-    get grantableCeiling() {
-        return this.capacity - this.resident;
-    }
-    acquire(bytes, signal, resident = false) {
+    acquire(bytes, signal) {
         if (signal?.aborted)
             return Promise.reject(abortError(signal));
-        // Refuse a claim no amount of waiting can satisfy, rather than parking it
-        // in the FIFO forever. A parked claim is indistinguishable from a caller
-        // that stopped: no error, no timeout, and — because the queue refuses
-        // everyone behind it — no further progress anywhere in the isolate. That
-        // is what a real-vite launch looked like for four rounds of debugging.
-        if (bytes > this.grantableCeiling) {
-            return Promise.reject(new RangeError(`weighted credit claim of ${bytes} bytes can never be granted: capacity is ${this.capacity} `
-                + `and ${this.resident} bytes are held by resident owners, leaving ${this.grantableCeiling}`));
-        }
-        const immediate = resident ? null : this.tryAcquire(bytes);
+        const immediate = this.tryAcquire(bytes);
         if (immediate)
             return Promise.resolve(immediate);
-        if (resident && this.waiters.length === 0 && this.current + bytes <= this.capacity) {
-            return Promise.resolve(this.grant(bytes, true));
-        }
         return new Promise((resolve, reject) => {
             const waiter = {
                 bytes,
-                resident,
                 resolve,
                 reject,
                 signal,
@@ -73,10 +48,8 @@ class CreditLane {
             this.drain();
         });
     }
-    grant(bytes, resident) {
+    grant(bytes) {
         this.current += bytes;
-        if (resident)
-            this.resident += bytes;
         this.peak = Math.max(this.peak, this.current);
         let leasedBytes = bytes;
         let released = false;
@@ -94,8 +67,6 @@ class CreditLane {
                     throw new RangeError(`weighted credit lease can only shrink to a positive safe integer no larger than ${leasedBytes}: ${nextBytes}`);
                 }
                 this.current -= leasedBytes - nextBytes;
-                if (resident)
-                    this.resident -= leasedBytes - nextBytes;
                 leasedBytes = nextBytes;
                 this.drain();
             },
@@ -104,8 +75,6 @@ class CreditLane {
                     return;
                 released = true;
                 this.current -= leasedBytes;
-                if (resident)
-                    this.resident -= leasedBytes;
                 if (this.current < 0) {
                     throw new Error('weighted credit accounting underflow');
                 }
@@ -126,7 +95,7 @@ class CreditLane {
                 return;
             this.waiters.shift();
             waiter.signal?.removeEventListener('abort', waiter.onAbort);
-            waiter.resolve(this.grant(waiter.bytes, waiter.resident));
+            waiter.resolve(this.grant(waiter.bytes));
         }
     }
 }
@@ -185,7 +154,6 @@ export class WeightedCreditPool {
             current: general.current + small.current,
             peak: general.peak + small.peak,
             queued: general.queued + small.queued,
-            resident: general.resident + small.resident,
         };
     }
     isSmall(bytes) {
@@ -216,22 +184,6 @@ export class WeightedCreditPool {
         }
         return this.general.acquire(bytes, signal);
     }
-    /**
-     * Take credit that will be held for the owner's whole lifetime rather than
-     * for one operation — the esbuild pool's wasm image is the case.
-     *
-     * Recorded as a floor so a later claim that could never fit around it is
-     * refused with both numbers instead of parking in the FIFO forever.
-     */
-    acquireResident(bytes, signal) {
-        try {
-            this.validateRequest(bytes);
-        }
-        catch (error) {
-            return Promise.reject(error);
-        }
-        return this.general.acquire(bytes, signal, true);
-    }
     validateRequest(bytes) {
         if (!Number.isSafeInteger(bytes) || bytes <= 0 || bytes > this.capacity) {
             throw new RangeError(`weighted credit request must be a positive safe integer no larger than ${this.capacity}: ${bytes}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/platform",
-  "version": "0.5.1",
+  "version": "0.7.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,12 +43,12 @@
     "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": {
-    "@cloudflare/workers-types": "^4.20250327.0",
+    "@cloudflare/workers-types": "^5.20260928.1",
     "typescript": "^5.7.0"
   },
   "publishConfig": {

package/src/composition.ts

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

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,12 +82,6 @@ export interface DiagCounters {
    * Surfaced as `breakdown.prefetchCacheBytes`. A gauge, not a delta.
    */
   prefetchCacheBytes: number;
-  /**
-   * Bytes retained by the FacetManager's ESM→CJS transform cache, bounded by
-   * ESM_TRANSFORM_CACHE_MAX_BYTES. Surfaced as `breakdown.transformCacheBytes`.
-   * A gauge, not a delta.
-   */
-  transformCacheBytes: number;
   /** Install-facet counters. Populated by npm-installer after a
    *  successful batch-facet dispatch returns. Confirms the install ran
    *  in the facet (tarballsCompleted > 0) and surfaces the
@@ -147,7 +141,6 @@ const _counters: DiagCounters = {
   inFlightRpcPayloadBytes: 0,
   prefetchBundleBytes: 0,
   prefetchCacheBytes: 0,
-  transformCacheBytes: 0,
   installFacet: {
     tarballsCompleted: 0,
     cumulativeBytesDecoded: 0,
@@ -250,12 +243,6 @@ 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,12 +200,6 @@ export interface HeapBreakdown {
    * the cache holds rather than a reservation it might use.
    */
   prefetchCacheBytes: number;
-  /**
-   * Bytes retained by the FacetManager's ESM→CJS transform cache
-   * (diag-counters `transformCacheBytes`), the other cache that persists
-   * across execs. Bounded by ESM_TRANSFORM_CACHE_MAX_BYTES.
-   */
-  transformCacheBytes: number;
   /**
    * Shared-budget occupancy not already represented by the named transient
    * counters. This covers full-budget owners and keeps cross-DO module-local
@@ -303,7 +297,6 @@ export function estimateSupervisorHeap(
     streamingBuffersBytes: c.inFlightRpcPayloadBytes,
     prefetchBundleBytes: c.prefetchBundleBytes,
     prefetchCacheBytes: c.prefetchCacheBytes,
-    transformCacheBytes: c.transformCacheBytes,
     unattributedReservationBytes: Math.max(
       0,
       allocationBudget.current - transientAttributedBytes,
@@ -318,7 +311,6 @@ export function estimateSupervisorHeap(
     breakdown.streamingBuffersBytes +
     breakdown.prefetchBundleBytes +
     breakdown.prefetchCacheBytes +
-    breakdown.transformCacheBytes +
     breakdown.unattributedReservationBytes;
 
   const percentOfCeiling = Math.round(