@nimbus-sh/platform 0.8.2 → 0.13.0

package/dist/composition.d.ts

@@ -33,11 +33,12 @@
  * the Durable Object classes, which is what lets the pool be unit-tested
  * in a plain Node/Bun process.
  */
+import type { WorkerCode } from './worker-code.js';
 export type EntrypointLoopbackFactory = <Stub = unknown>(options: {
     props: object;
 }) => Stub;
 export type CtxExports = Record<string, EntrypointLoopbackFactory | undefined>;
-export type StagedBootAssembler = (env: unknown, stage: unknown) => Promise<object>;
+export type StagedBootAssembler = (env: unknown, stage: unknown) => Promise<WorkerCode>;
 export interface FabricComposition {
     supervisorEntrypoint: string;
     stagedBootAssembler?: StagedBootAssembler;
@@ -67,7 +68,7 @@ export declare const DEFAULT_HOST_DISPATCH_METHOD = "supervisorOp";
  * 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. A host without
- * `enhanced_error_serialization` is refused.
+ * `enhanced_error_serialization` or `enable_request_signal` is refused.
  */
 export declare function composeFabric(value: FabricComposition): void;
 export declare function adoptCtxExports(value: CtxExports): void;

package/dist/composition.d.ts.map

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

package/dist/composition.js

@@ -3,11 +3,17 @@ export const DEFAULT_HOST_DISPATCH_METHOD = 'supervisorOp';
 let composition = null;
 let ctxExports = null;
 /**
- * A program's filesystem errors reach it across workerd RPC, from the host
- * that answers its supervisor binding, and the program branches on the POSIX
- * `code` each one carries. workerd carries an error's own properties across
- * RPC only when the sending AND the receiving isolate have
- * `enhanced_error_serialization`, on by compatibility date from 2026-04-21:
+ * The compatibility flags a host composes the fabric under, refused without.
+ * Composing refuses wherever it composes (module scope: the Worker fails at
+ * startup; NimbusWorkspace.create: that call throws), naming the fix. Off
+ * workerd (bun, node) there is no `Cloudflare` global to read, and neither
+ * flag has anything to act on.
+ *
+ * `enhanced_error_serialization`: 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 the flag, 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
@@ -15,32 +21,41 @@ let ctxExports = null;
  * 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.
+ * it maps to EIO. The flag alone keeps every other behavior of that date.
+ *
+ * `enable_request_signal`, which no compatibility date enables: a process
+ * owns work for a response until its client is done with it, and a client
+ * that goes away is seen only as the incoming request's `signal` aborting
+ * (src/workerd/io/worker-entrypoint.c++, "The client has disconnected").
+ * Without it a response whose client left keeps its process's work, and the
+ * host that runs it, held until the process writes again, or for good.
  */
-function requireEnhancedErrorSerialization() {
+function requireHostFlags() {
     // `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.');
+    if (Cloudflare.compatibilityFlags.enhanced_error_serialization !== true) {
+        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.');
+    }
+    if (Cloudflare.compatibilityFlags.enable_request_signal !== true) {
+        throw new Error('fabric: this Worker runs without the enable_request_signal compatibility flag, so a process '
+            + 'cannot see a client leave the response it is serving, and keeps that work held. Add '
+            + '"enable_request_signal" to compatibility_flags in your wrangler config; no compatibility '
+            + 'date enables it.');
+    }
 }
 /**
  * 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. A host without
- * `enhanced_error_serialization` is refused.
+ * `enhanced_error_serialization` or `enable_request_signal` is refused.
  */
 export function composeFabric(value) {
-    requireEnhancedErrorSerialization();
+    requireHostFlags();
     if (!composition) {
         composition = value;
         return;

package/dist/crc32.d.ts

@@ -9,11 +9,11 @@
  * 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.
+ * workerd, so below 128 bytes the table loop wins there. It is the realm's
+ * own (realmBuiltin), like core's incremental SHA-256's, so this module 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

@@ -1 +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"}
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../src/crc32.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAkCH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,SAAI,GAAG,MAAM,CAiB7D"}

package/dist/crc32.js

@@ -9,22 +9,18 @@
  * 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.
+ * workerd, so below 128 bytes the table loop wins there. It is the realm's
+ * own (realmBuiltin), like core's incremental SHA-256's, so this module 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.
  */
+import { realmBuiltin } from './realm-builtin.js';
 /** 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;
-    }
+    const crc32 = realmBuiltin('node:zlib')?.crc32;
+    return typeof crc32 === 'function' ? crc32 : null;
 })();
 /** Eight 256-entry tables: table k maps a byte to its CRC after k further zero bytes. */
 let crcTables = null;

package/dist/diag-counters.d.ts

@@ -27,6 +27,7 @@
  *
  */
 import type { InstallPhase } from './install-phase.js';
+import { type AllocationAttribution, type SupervisorAllocationLease } from './heavy-alloc-coord.js';
 export interface DiagCounters {
     /** Top-level install phase. */
     installPhase: InstallPhase;
@@ -55,13 +56,22 @@ export interface DiagCounters {
      * `buildPrefetchBundle` accumulates raw VFS file contents into an in-heap
      * bundle object, and used to do so with nothing observing it: the estimator
      * read 9.4 MiB while those bytes were resetting the DO. Each build now takes
-     * an `acquireSupervisorAllocation` lease for the budget it may use and bumps
-     * this alongside it, so the reservation is ATTRIBUTED to the bundle path
-     * rather than landing in `unattributedReservationBytes`.
+     * an `acquireSupervisorAllocation` lease for the budget it may use, counted
+     * here while it is held (attributeAllocation), so the reservation is
+     * ATTRIBUTED to the bundle path rather than landing in
+     * `unattributedReservationBytes`.
      *
      * Surfaced as `breakdown.prefetchBundleBytes`. Back to zero between builds.
      */
     prefetchBundleBytes: number;
+    /**
+     * Bytes the slices of pre-bundles in flight hold: each build's lease
+     * (browser-prebundle.ts), counted while it is held (attributeAllocation),
+     * after it shrinks to the slice it walked.
+     *
+     * Surfaced as `breakdown.preBundleSliceBytes`. Back to zero between builds.
+     */
+    preBundleSliceBytes: number;
     /**
      * Bytes retained by the FacetManager's prefetch-bundle LRU right now.
      *
@@ -172,15 +182,13 @@ export declare function rpcPayloadStart(bytes: number): void;
  * hit is a bug worth investigating.
  */
 export declare function rpcPayloadEnd(bytes: number): void;
+/** The counters that name the live allocation leases of one owner. */
+export type AllocationOwner = AllocationAttribution;
 /**
- * Track an in-flight prefetch-bundle build. Call with the byte reservation the
- * build took from the supervisor allocation budget, and pair with
- * `prefetchBundleEnd` in the matching `finally` so it returns to zero whether
- * the build succeeded or threw.
+ * Attribution belongs to the budget's actual lease. The public gauges are
+ * derived from its holders, never maintained in a second counter registry.
  */
-export declare function prefetchBundleStart(bytes: number): void;
-/** Release an in-flight prefetch-bundle reservation. Floors at 0. */
-export declare function prefetchBundleEnd(bytes: number): void;
+export declare function attributeAllocation(owner: AllocationOwner, lease: SupervisorAllocationLease): SupervisorAllocationLease;
 /**
  * Publish the prefetch-bundle LRU's live retained total. A gauge: the cache
  * owns the number and reports it whenever it admits or evicts an entry.

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

@@ -18,10 +18,10 @@
  * reboot — itself a useful signal (counters at 0 immediately after the
  * banner reprinted = the killed isolate took its state with it).
  */
+import { readSupervisorAllocationAttribution } from './heavy-alloc-coord.js';
 const _counters = {
     installPhase: 'idle',
     inFlightRpcPayloadBytes: 0,
-    prefetchBundleBytes: 0,
     prefetchCacheBytes: 0,
     supervisorAnsweredBytes: 0,
     installFacet: {
@@ -46,7 +46,7 @@ const _counters = {
 };
 /** Read a snapshot — caller-side mutations don't affect the singleton. */
 export function readDiagCounters() {
-    return { ..._counters };
+    return { ..._counters, ...readSupervisorAllocationAttribution() };
 }
 /** Count `bytes` the session answered a process's supervisor call with. */
 export function recordSupervisorAnswer(bytes) {
@@ -99,25 +99,12 @@ export function rpcPayloadEnd(bytes) {
     }
 }
 /**
- * Track an in-flight prefetch-bundle build. Call with the byte reservation the
- * build took from the supervisor allocation budget, and pair with
- * `prefetchBundleEnd` in the matching `finally` so it returns to zero whether
- * the build succeeded or threw.
+ * Attribution belongs to the budget's actual lease. The public gauges are
+ * derived from its holders, never maintained in a second counter registry.
  */
-export function prefetchBundleStart(bytes) {
-    const n = Number(bytes);
-    if (!Number.isFinite(n) || n <= 0)
-        return;
-    _counters.prefetchBundleBytes += n;
-}
-/** Release an in-flight prefetch-bundle reservation. Floors at 0. */
-export function prefetchBundleEnd(bytes) {
-    const n = Number(bytes);
-    if (!Number.isFinite(n) || n <= 0)
-        return;
-    _counters.prefetchBundleBytes -= n;
-    if (_counters.prefetchBundleBytes < 0)
-        _counters.prefetchBundleBytes = 0;
+export function attributeAllocation(owner, lease) {
+    lease.attribute(owner);
+    return lease;
 }
 /**
  * Publish the prefetch-bundle LRU's live retained total. A gauge: the cache

package/dist/heap-estimate.d.ts

@@ -149,9 +149,11 @@ export interface HeapBreakdown {
     vfsLruBytes: number;
     /** SqliteVFS current logical retained write payload bytes. */
     vfsInFlightBytes: number;
-    /** Pre-bundle slice bytes resident in supervisor heap (peak across
-     *  in-flight pool slots × SLICE_CAP_BYTES). Drops to 0 once
-     *  A'.2/A'.3 stream the slice through ReadableStream-over-RPC. */
+    /**
+     * Bytes the slices of pre-bundles in flight hold (diag-counters
+     * `preBundleSliceBytes`): each build's lease, from its worst case down to
+     * the slice it walked, released as the build ends, however it ends.
+     */
     preBundleSliceBytes: number;
     /**
      * In-flight supervisor RPC payload bytes (Phase 2 A'.2).
@@ -198,23 +200,6 @@ export interface VfsHeapInputs {
     /** Current sum of in-flight write payloads (or 0 if none). */
     inFlightWriteBytes: number;
 }
-/**
- * Estimate pre-bundle slice bytes resident in the supervisor heap.
- *
- * Pre A'.2: the supervisor builds the slice in heap (up to
- * SLICE_CAP_BYTES = 28 MiB per concurrent slot) before passing to the
- * pre-bundle facet. With PRE_BUNDLE_CONCURRENCY = 1 the cap is 28 MiB.
- *
- * Diag counters track pre-bundle attempts/completions but not
- * in-flight slice bytes specifically. Until A'.2 streams the slice,
- * we treat the slice as PRESENT in supervisor heap iff the pre-bundle
- * phase is active AND a slot is in flight (no completion yet for the
- * current attempted count).
- *
- * After A'.2 lands the slice flows via ReadableStream-over-RPC and
- * supervisor never holds the bytes — this contribution drops to 0.
- */
-export declare function estimatePreBundleSliceBytes(c: DiagCounters): number;
 /**
  * Build a heap estimate from runtime counters + VFS inputs.
  *

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;AAGH,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;;;;OAIG;IACH,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;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,YAAY,EACf,GAAG,EAAE,aAAa,GACjB,YAAY,CAiDd"}

package/dist/heap-estimate.js

@@ -57,7 +57,7 @@
  * The actual count of evictions Nimbus has observed lives in the C'.2
  * recovery_event ring, separate from this module.
  */
-import { PRE_BUNDLE_CONCURRENCY, PRE_BUNDLE_SLICE_CAP_BYTES, SUPERVISOR_HEAP_CEILING_BYTES, } from './limits.js';
+import { SUPERVISOR_HEAP_CEILING_BYTES } from './limits.js';
 import { readSupervisorAllocationBudget, } from './heavy-alloc-coord.js';
 /**
  * Five labelled workerd eviction reasons. Surfaced as a constant
@@ -110,32 +110,6 @@ export const HEAP_BLIND_SPOTS = [];
  * would lower this further.
  */
 const SUPERVISOR_BASELINE_BYTES = 9 * 1024 * 1024;
-/**
- * Estimate pre-bundle slice bytes resident in the supervisor heap.
- *
- * Pre A'.2: the supervisor builds the slice in heap (up to
- * SLICE_CAP_BYTES = 28 MiB per concurrent slot) before passing to the
- * pre-bundle facet. With PRE_BUNDLE_CONCURRENCY = 1 the cap is 28 MiB.
- *
- * Diag counters track pre-bundle attempts/completions but not
- * in-flight slice bytes specifically. Until A'.2 streams the slice,
- * we treat the slice as PRESENT in supervisor heap iff the pre-bundle
- * phase is active AND a slot is in flight (no completion yet for the
- * current attempted count).
- *
- * After A'.2 lands the slice flows via ReadableStream-over-RPC and
- * supervisor never holds the bytes — this contribution drops to 0.
- */
-export function estimatePreBundleSliceBytes(c) {
-    // Conservative: if the most recent batch attempted >0 specs and the
-    // batch hasn't fully completed, assume one slice's worth of bytes
-    // are in flight.
-    const f = c.preBundleFacet;
-    const inFlight = f.attempted - f.bundlesCompleted - f.errors - f.skipped;
-    if (inFlight <= 0)
-        return 0;
-    return Math.min(inFlight, PRE_BUNDLE_CONCURRENCY) * PRE_BUNDLE_SLICE_CAP_BYTES;
-}
 /**
  * Build a heap estimate from runtime counters + VFS inputs.
  *
@@ -144,19 +118,18 @@ export function estimatePreBundleSliceBytes(c) {
  */
 export function estimateSupervisorHeap(c, vfs) {
     const allocationBudget = readSupervisorAllocationBudget();
-    const preBundleSliceBytes = estimatePreBundleSliceBytes(c);
-    // The prefetch build holds a lease, so its bytes are already inside
-    // allocationBudget.current — naming it here moves it out of the
-    // unattributed remainder rather than adding to the total twice.
+    // The prefetch build and the pre-bundle hold leases, so their bytes are
+    // already inside allocationBudget.current — naming them here moves them out
+    // of the unattributed remainder rather than adding to the total twice.
     const transientAttributedBytes = vfs.inFlightWriteBytes +
-        preBundleSliceBytes +
+        c.preBundleSliceBytes +
         c.inFlightRpcPayloadBytes +
         c.prefetchBundleBytes;
     const breakdown = {
         supervisorBaselineBytes: SUPERVISOR_BASELINE_BYTES,
         vfsLruBytes: vfs.cacheHotBytes,
         vfsInFlightBytes: vfs.inFlightWriteBytes,
-        preBundleSliceBytes,
+        preBundleSliceBytes: c.preBundleSliceBytes,
         streamingBuffersBytes: c.inFlightRpcPayloadBytes,
         prefetchBundleBytes: c.prefetchBundleBytes,
         prefetchCacheBytes: c.prefetchCacheBytes,

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

@@ -13,6 +13,40 @@ export interface SupervisorAllocationBudgetStats {
     readonly current: number;
     readonly peak: number;
     readonly queued: number;
+    readonly holders: SupervisorAllocationHolder[];
+    readonly waiting: SupervisorAllocationHolder[];
+}
+export type AllocationAttribution = 'prefetchBundleBytes' | 'preBundleSliceBytes';
+export interface SupervisorAllocationOwner {
+    owner: string;
+    pid?: number;
+    session?: string;
+    attribution?: AllocationAttribution;
+}
+export interface SupervisorAllocationHolder {
+    owner: string;
+    bytes: number;
+    ageMs: number;
+    pid?: number;
+    session?: string;
+}
+export interface SupervisorAllocationLease extends ResizableCreditLease {
+    attribute(attribution: AllocationAttribution): void;
+}
+/**
+ * A facet's load the budget did not admit within its bound
+ * (SUPERVISOR_LOAD_WAIT_MS): nothing of it was read, and the facet is not
+ * started. Resource temporarily unavailable, as the ledger's refusal of a
+ * wait no release can satisfy is.
+ */
+export declare class SupervisorLoadWaitError extends Error {
+    readonly load: string;
+    readonly bytes: number;
+    readonly waitedMs: number;
+    readonly held: SupervisorAllocationBudgetStats;
+    readonly code = "EAGAIN";
+    readonly errno = -11;
+    constructor(load: string, bytes: number, waitedMs: number, held: SupervisorAllocationBudgetStats);
 }
 interface AllocationBudgetLifecycle {
     onActive?: () => void;
@@ -33,14 +67,17 @@ export declare class SupervisorAllocationBudget {
      * cache it is filling.
      */
     private lifecycleHolders;
+    private readonly holders;
+    private readonly waiting;
     constructor(capacity: number, lifecycle?: AllocationBudgetLifecycle, reserve?: WeightedCreditPoolOptions);
     get stats(): SupervisorAllocationBudgetStats;
+    get attributed(): Record<AllocationAttribution, number>;
     /**
      * Reserve bytes and, while held, mark the budget active so observers can
      * free heap headroom. For owners whose payload is what the headroom is for:
      * installs, clones, pre-bundles, boot payloads, streamed writes.
      */
-    acquire(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
+    acquire(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
     /**
      * Reserve bytes WITHOUT driving the cache lifecycle, for owners that are
      * filling the disposable cache rather than competing with it. Shrinking a
@@ -50,9 +87,45 @@ export declare class SupervisorAllocationBudget {
      * never warming. The byte credit is still taken — back-pressure is what
      * stops a large read overlapping a large write.
      */
-    acquireWithoutLifecycle(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
-    /** Reserve bytes now or not at all, driving the lifecycle as acquire does. */
-    tryAcquire(bytes: number): ResizableCreditLease | null;
+    acquireWithoutLifecycle(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+    /**
+     * Reserve what a facet's load holds while the loader takes its module map:
+     * `bytes`, or for a load larger than the whole budget the whole budget, so
+     * that it holds it alone and every owner after it waits. Granted in the
+     * budget's one FIFO order, so no owner queued after a load overtakes it,
+     * however small, and refused with SupervisorLoadWaitError when not granted
+     * within `waitMs`. Like a copy it holds bytes the session already has, for
+     * as long as the load takes, so the disposable VFS cache is not shrunk.
+     */
+    acquireLoad(load: string, bytes: number, options: {
+        waitMs: number;
+        signal?: AbortSignal;
+        owner?: SupervisorAllocationOwner;
+    }): Promise<SupervisorAllocationLease>;
+    /** Reclaimers of parked launches' retained credit, oldest registered first (reclaimable). */
+    private readonly reclaimers;
+    /**
+     * Register `reclaim`, which gives a parked launch's retained credit back
+     * before it returns (its map dropped, its lease released, the launch sent
+     * back to prepare), for running work to call when nothing else frees what
+     * it needs (acquireRunning). Unregistered just before it is called; the
+     * returned function unregisters it.
+     */
+    reclaimable(reclaim: () => void): () => void;
+    /**
+     * Running work's credit, the lock order's one exception
+     * (acquireSupervisorLoad): granted at once where it fits, ahead of every
+     * queued ask; else, queued ahead of them all, it reclaims parked launches'
+     * retained credit, the oldest first, until it is granted; else it waits
+     * only for credit other running work holds.
+     */
+    acquireRunning(bytes: number, signal?: AbortSignal, drivesLifecycle?: boolean, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+    /** Reclaim parked launches' credit, the oldest parked first, while a running ask waits: what a reclaim frees goes to running asks first. */
+    private reclaimForRunning;
+    /** acquireRunning's credit now, ahead of every queued ask, without reclaiming, or null. */
+    tryAcquireRunning(bytes: number, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
+    /** Reserve bytes now or not at all, driving the lifecycle as acquire does (or not, `drivesLifecycle` false). */
+    tryAcquire(bytes: number, drivesLifecycle?: boolean, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
     private _acquire;
     private wrap;
 }
@@ -79,20 +152,67 @@ export declare function registerAllocObserver(o: AllocObserver): () => void;
 /**
  * Reserve an exact number of supervisor-resident bytes.
  */
-export declare function acquireSupervisorAllocation(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
+export declare function acquireSupervisorAllocation(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
 /** Reserve bytes now if they can be granted without waiting, else null. */
-export declare function tryAcquireSupervisorAllocation(bytes: number): ResizableCreditLease | null;
+export declare function tryAcquireSupervisorAllocation(bytes: number, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
+/**
+ * Reserve bytes for a running process's filesystem READ (its read RPCs):
+ * running work (acquireRunning), which does not shrink the disposable VFS
+ * cache, which reads are there to fill.
+ */
+export declare function acquireSupervisorReadAllocation(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+/**
+ * Reserve bytes for a short-lived copy of what the session already holds
+ * (a launch's module map made from a staged state), now or not at all, or
+ * by waiting (`signal`): the byte credit bounds how many such copies are
+ * live at once, but the disposable VFS cache is not shrunk for one, as it
+ * is not for a read. Shrinking it for every launch of a program already
+ * built cost each one its cache, and the copy is no install.
+ */
+export declare function tryAcquireSupervisorCopyAllocation(bytes: number, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
+/** {@link tryAcquireSupervisorCopyAllocation}, waiting for room. */
+export declare function acquireSupervisorCopyAllocation(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+/**
+ * `bytes` of this isolate for a facet's load (the wasm images read for it;
+ * `name` says whose), admitted on the supervisor budget
+ * (SupervisorAllocationBudget.acquireLoad): FIFO, the whole budget for one
+ * larger than it, refused by name after SUPERVISOR_LOAD_WAIT_MS. `signal`
+ * ends the wait.
+ *
+ * Lock order: supervisor credit, then a Dynamic Worker. Nothing waits for
+ * credit (SupervisorAllocationBudget acquire or acquireLoad, or growing a
+ * lease) while it holds a worker's fetch hold (beginLoaderFetch,
+ * claimAdmission, readmitRefused). While it holds one, it may give credit
+ * back, shrink it, or take credit without waiting (tryAcquire). Running work
+ * is the one exception, and comes first. Credit a running process needs (its
+ * write waves and the session RPCs it makes, through acquireRunning)
+ * overtakes every queued ask. When nothing else frees it, it reclaims parked
+ * launches' retained maps, oldest parked first: each is dropped, its launch
+ * is sent back to prepare, and the map is rebuilt at that launch's turn.
+ * Otherwise it waits only for credit other running work holds. A facet's load
+ * is not running work.
+ */
+export declare function acquireSupervisorLoad(name: string, bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+/** acquireSupervisorLoad's credit now, without waiting, or null: all a load may take while it holds a worker. */
+export declare function tryAcquireSupervisorLoad(bytes: number, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
 /**
- * Reserve bytes for a filesystem READ. Takes the same byte credit as any
- * other owner but does not shrink the disposable VFS cache, which reads are
- * there to fill.
+ * Running work's credit (SupervisorAllocationBudget.acquireRunning): what a
+ * running process needs to go on (its write waves, the session RPCs it
+ * makes), never held up by a launch that is not running.
  */
-export declare function acquireSupervisorReadAllocation(bytes: number, signal?: AbortSignal): Promise<ResizableCreditLease>;
+export declare function acquireSupervisorRunningAllocation(bytes: number, signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<SupervisorAllocationLease>;
+/** acquireSupervisorRunningAllocation's credit now, ahead of every queued ask, without reclaiming, or null. */
+export declare function tryAcquireSupervisorRunningAllocation(bytes: number, owner?: SupervisorAllocationOwner): SupervisorAllocationLease | null;
+/** Register a parked launch's reclaimer on the isolate's budget (SupervisorAllocationBudget.reclaimable). */
+export declare function reclaimableSupervisorAllocation(reclaim: () => void): () => void;
+/** Run `load` holding acquireSupervisorLoad's credit for `bytes`, given back as it settles; for a load no worker hold waits on. */
+export declare function withSupervisorLoadAllocation<T>(name: string, bytes: number, signal: AbortSignal | undefined, load: () => Promise<T>, owner?: SupervisorAllocationOwner): Promise<T>;
 /**
  * Reserve the full budget for an allocation whose retained size is not known
  * accurately enough to overlap safely with other heavy work.
  */
-export declare function acquireHeavyAlloc(signal?: AbortSignal): Promise<() => void>;
+export declare function acquireHeavyAlloc(signal?: AbortSignal, owner?: SupervisorAllocationOwner): Promise<() => void>;
 export declare function readSupervisorAllocationBudget(): SupervisorAllocationBudgetStats;
+export declare function readSupervisorAllocationAttribution(): Record<AllocationAttribution, number>;
 export {};
 //# sourceMappingURL=heavy-alloc-coord.d.ts.map

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

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