@nimbus-sh/fabric 0.7.1 → 0.9.0

package/dist/host-wasm.js

@@ -0,0 +1,31 @@
+/**
+ * host-wasm.ts — what the fabric knows about a WebAssembly.Module a host
+ * hands a dynamic worker already compiled.
+ *
+ * workerd accepts a compiled module in a Worker Loader module map and lets
+ * the dynamic worker share its compiled code (src/workerd/api/
+ * worker-loader.c++, extractWasmModuleContent), so a host that bundles a
+ * fixed wasm (esbuild's, say) hands that module over instead of fetching a
+ * second copy of the bytes and having the guest compile them again. Two
+ * things the fabric needs about a member are unreadable from JS for a
+ * Module:
+ *   - its size: the module's wire bytes still count toward the 64 MiB
+ *     dynamic-worker code limit (worker-loader.c++ sums every member), and
+ *     assertModuleMapWithinCodeLimit must count them;
+ *   - its identity: a pool folds its wasm into the loader cache key, and a
+ *     Module has no bytes to fingerprint.
+ * The host that owns the module states both once, here.
+ */
+const described = new WeakMap();
+/** Record what `module` is, and return it. */
+export function describeHostWasm(module, identity) {
+    if (!Number.isSafeInteger(identity.bytes) || identity.bytes <= 0) {
+        throw new RangeError(`describeHostWasm: '${identity.id}' needs its wire size in bytes, got ${identity.bytes}`);
+    }
+    described.set(module, identity);
+    return module;
+}
+/** What a host said `module` is, or undefined for a module nobody described. */
+export function hostWasmIdentity(module) {
+    return described.get(module);
+}

package/dist/image-store.d.ts

@@ -105,7 +105,7 @@ export declare class ImageStore {
      * Writing the sources here, once, is what lets the session stop holding
      * them: after this returns, the only thing it keeps is a path.
      */
-    materialize(pid: number, images: AsyncIterable<readonly [string, string]> | Iterable<readonly [string, string]>, pacer: TurnBudget): Promise<Record<string, string>>;
+    materialize(pid: number, images: AsyncIterable<readonly [string, string | readonly string[]]> | Iterable<readonly [string, string | readonly string[]]>, pacer: TurnBudget): Promise<Record<string, string>>;
     /**
      * Drop every image no running process boots from.
      *

package/dist/image-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-store.d.ts","sourceRoot":"","sources":["../src/image-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,QAA0D,CAAC;AAErG;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,wEAAwE;IACxE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACjD,kDAAkD;IAClD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAClE,2EAA2E;IAC3E,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,qDAAqD;IACrD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,qBAAa,UAAU;IAanB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAbzB,8EAA8E;IAC9E,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;OAMG;gBAEgB,KAAK,EAAE,MAAM,cAAc,EAC3B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO;IAGnD;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,IAAI,IAAI;IAOjB;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,CACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtF,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAuDlC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,KAAK;CAgBd"}
+{"version":3,"file":"image-store.d.ts","sourceRoot":"","sources":["../src/image-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD;;;;;;;;;GASG;AACH,eAAO,MAAM,6BAA6B,QAA0D,CAAC;AAErG;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,wEAAwE;IACxE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,wEAAwE;IACxE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACjD,kDAAkD;IAClD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IAClE,2EAA2E;IAC3E,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B,qDAAqD;IACrD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,qBAAa,UAAU;IAanB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAbzB,8EAA8E;IAC9E,OAAO,CAAC,cAAc,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;OAMG;gBAEgB,KAAK,EAAE,MAAM,cAAc,EAC3B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO;IAGnD;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,IAAI,IAAI;IAOjB;;;;;;;;;;;;;;;;OAgBG;IACG,WAAW,CACf,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC,CAAC,EAC9H,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAuDlC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,KAAK;CAgBd"}

package/dist/image-store.js

@@ -111,12 +111,12 @@ export class ImageStore {
         fs.mkdirp(FACET_IMAGE_DIR);
         let count = 0;
         for await (const [moduleName, source] of images) {
-            const path = facetImagePath(await facetImageDigest(source));
+            const bytes = typeof source === 'string' ? new TextEncoder().encode(source) : encodeParts(source);
+            const path = facetImagePath(await facetImageDigest(bytes));
             paths[moduleName] = path;
             rooted.push(path);
             count++;
             const stored = path.replace(/^\/+/, '');
-            const bytes = new TextEncoder().encode(source);
             console.log('[image-store] pid=' + pid + ' image ' + count + ' ' + moduleName + ' → '
                 + path.slice(-12) + ' ' + bytes.byteLength + ' bytes, slice=' + FACET_IMAGE_WRITE_SLICE_BYTES
                 + ' turns=' + pacer.chunks);
@@ -190,3 +190,35 @@ export class ImageStore {
         }
     }
 }
+/**
+ * UTF-8 bytes of an image given as ordered parts, encoded into one buffer a
+ * part at a time: joining the parts first would hold the whole image twice as
+ * text.
+ */
+function encodeParts(parts) {
+    let length = 0;
+    for (const part of parts) {
+        for (let i = 0; i < part.length; i++) {
+            const code = part.charCodeAt(i);
+            if (code < 0x80)
+                length += 1;
+            else if (code < 0x800)
+                length += 2;
+            else if (code >= 0xd800 && code <= 0xdbff && (part.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
+                length += 4;
+                i++;
+            }
+            else
+                length += 3;
+        }
+    }
+    const bytes = new Uint8Array(length);
+    const encoder = new TextEncoder();
+    let offset = 0;
+    for (const part of parts) {
+        const encoded = encoder.encode(part);
+        bytes.set(encoded, offset);
+        offset += encoded.byteLength;
+    }
+    return bytes;
+}

package/dist/inner-do-registry.d.ts

@@ -38,4 +38,13 @@ export declare function getInnerDoClass(supervisorDoId: string, bindingName: str
 export declare function registerInnerDoClass(supervisorDoId: string, bindingName: string, cls: DurableObjectClass): void;
 /** Clear all registrations belonging to a supervisor DO (called on rebuild). */
 export declare function clearInnerDoClasses(supervisorDoId: string): void;
+/**
+ * Record that this incarnation opens `facetName` for `bindingName`. True on the
+ * name's first open since the incarnation began or the binding's facets were
+ * last aborted: whatever still runs under it has a class this build no longer
+ * uses, and a get() with the new class on it resets the whole object.
+ */
+export declare function noteInnerDoFacetOpened(ctx: DurableObjectState, bindingName: string, facetName: string): boolean;
+/** Abort the facets this incarnation opened for `bindingNames`, keeping their storage, so each next request starts the class registered then. */
+export declare function abortInnerDoFacets(ctx: DurableObjectState, bindingNames: Iterable<string>, reason: Error): void;
 //# sourceMappingURL=inner-do-registry.d.ts.map

package/dist/inner-do-registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inner-do-registry.d.ts","sourceRoot":"","sources":["../src/inner-do-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAE3G;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAEN;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAKhE"}
+{"version":3,"file":"inner-do-registry.d.ts","sourceRoot":"","sources":["../src/inner-do-registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAE3G;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,cAAc,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAEN;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAKhE;AAKD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAQ/G;AAED,iJAAiJ;AACjJ,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,EAAE,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAS/G"}

package/dist/inner-do-registry.js

@@ -49,3 +49,38 @@ export function clearInnerDoClasses(supervisorDoId) {
             _NIMBUS_INNER_DO_CLASSES.delete(k);
     }
 }
+/** Inner-DO facet names each incarnation has opened, by binding; keyed off ctx, so a new incarnation starts empty. */
+const openedInnerDoFacets = new WeakMap();
+/**
+ * Record that this incarnation opens `facetName` for `bindingName`. True on the
+ * name's first open since the incarnation began or the binding's facets were
+ * last aborted: whatever still runs under it has a class this build no longer
+ * uses, and a get() with the new class on it resets the whole object.
+ */
+export function noteInnerDoFacetOpened(ctx, bindingName, facetName) {
+    let byBinding = openedInnerDoFacets.get(ctx);
+    if (!byBinding)
+        openedInnerDoFacets.set(ctx, byBinding = new Map());
+    let names = byBinding.get(bindingName);
+    if (!names)
+        byBinding.set(bindingName, names = new Set());
+    if (names.has(facetName))
+        return false;
+    names.add(facetName);
+    return true;
+}
+/** Abort the facets this incarnation opened for `bindingNames`, keeping their storage, so each next request starts the class registered then. */
+export function abortInnerDoFacets(ctx, bindingNames, reason) {
+    const byBinding = openedInnerDoFacets.get(ctx);
+    if (!byBinding)
+        return;
+    for (const bindingName of bindingNames) {
+        for (const facetName of byBinding.get(bindingName) ?? []) {
+            try {
+                ctx.facets.abort(facetName, reason);
+            }
+            catch { /* already gone */ }
+        }
+        byBinding.delete(bindingName);
+    }
+}

package/dist/isolate-pool.d.ts

@@ -7,15 +7,15 @@
  *      running 67 npm tarball extractions (cold-start dominates). We pin
  *      each job to `slot = cursor % concurrency` and use stable loader
  *      IDs `nfp:${fnHash}:slot-${i}:g${generation}`, so a pool of
- *      concurrency=4 keeps at most 4 warm isolates rather than N fresh ones.
+ *      concurrency=N keeps at most N warm isolates rather than one per job.
  *   2. **Nimbus defaults**: compatibilityDate = CF_COMPAT_DATE (matches
- *      the supervisor worker), compatibilityFlags = ['nodejs_compat'],
+ *      the supervisor worker), compatibilityFlags = GUEST_COMPAT_FLAGS,
  *      globalOutbound = undefined (inherit parent network so the facet can
  *      reach https://registry.npmjs.org without a proxy binding).
  *   3. **Supervisor autoinjection**. The pool grabs the embedder's
  *      registered supervisor entrypoint stub (see `supervisorEntrypoint` in
  *      composition.ts) and forwards it as `env.SUPERVISOR` to every facet,
- *      same pattern as git-network-facet.ts. Callers can add more bindings
+ *      same pattern as git/network-facet.ts. Callers can add more bindings
  *      via `extraBindings`.
  *   4. **Fail-loud defaults**: timeout 60s, retries 0, onError 'throw'.
  *      Caller opts in to leniency.
@@ -44,7 +44,11 @@ export interface IsolatePoolEnv {
 }
 /** Options handed to IsolatePool's constructor. */
 export interface IsolatePoolOptions {
-    /** Maximum concurrent in-flight facets. Default 4. */
+    /**
+     * Maximum concurrent in-flight facets, each a distinct Dynamic Worker
+     * spent from the hosting DO's `DO_DYNAMIC_WORKER_LIMIT`. Default 1; a
+     * caller that wants more sizes it against that budget (Fanout does).
+     */
     concurrency?: number;
     /** Per-task timeout in ms. Default 60_000. */
     timeoutMs?: number;
@@ -139,15 +143,19 @@ export interface IsolatePoolOptions {
     /**
      * WebAssembly modules to ship into the facet via the LOADER's
      * `modules` map. Map keys are module specifier paths (e.g.
-     * `'esbuild.wasm'`); values are the raw bytes.
+     * `'esbuild.wasm'`); values are the raw bytes, or a module the host
+     * already holds compiled.
      *
-     * Workerd registers each entry as `{ wasm: ArrayBuffer }` in the
-     * worker's modules map. The pool prepends a static
+     * Workerd registers each entry as `{ wasm }` in the worker's modules
+     * map. The pool prepends a static
      * `import __NIMBUS_WASM_<id> from './<key>';` to the generated
-     * worker.js so workerd compiles each at module-load (startup phase,
-     * where wasm code generation is permitted). The compiled Modules
-     * are exposed via `globalThis.__NIMBUS_WASM[<key>]` for the user
-     * function to read at request time.
+     * worker.js; bytes are compiled at the facet's module-load (startup
+     * phase, where wasm code generation is permitted), and a compiled
+     * module is shared with the facet as is, its compiled code included
+     * (workerd src/workerd/api/worker-loader.c++,
+     * extractWasmModuleContent). The Modules are exposed via
+     * `globalThis.__NIMBUS_WASM[<key>]` for the user function to read at
+     * request time.
      *
      * Why this works when other paths don't:
      *   - request-time `WebAssembly.compile()` — disallowed by workerd
@@ -156,15 +164,15 @@ export interface IsolatePoolOptions {
      *     structured-clone refuses ("Unable to deserialize cloned data").
      *   - inlining bytes in the preamble — 16 MiB string per dispatch
      *     OOMs the supervisor at module-source allocation time.
-     *   - LOADER modules-map (this) — bytes ride INSIDE the worker code
-     *     blob; workerd compiles wasm during its own startup pipeline,
-     *     never crossing structured-clone, never executing JS eval.
+     *   - LOADER modules-map (this) — the module rides INSIDE the worker
+     *     code blob, never crossing structured-clone, never executing JS
+     *     eval.
      *
-     * The bytes ARE part of the loader-cache key (workerd hashes the
-     * whole WorkerCode), so changing the wasm bytes invalidates warm
-     * slots — desirable when the bundled wasm version changes.
+     * A compiled module must be described (host-wasm.ts describeHostWasm):
+     * its identity keys warm slots, as the bytes' fingerprint does, and its
+     * size counts toward the dynamic-worker code limit.
      */
-    wasmModules?: Record<string, ArrayBuffer>;
+    wasmModules?: Record<string, ArrayBuffer | WebAssembly.Module>;
 }
 /** Per-call override (merged with pool defaults). */
 export interface IsolateCallOptions {
@@ -233,7 +241,7 @@ export declare function assembleLoaderWorkerModuleSource(options: LoaderWorkerMo
  * Typical use:
  *
  *   const pool = new IsolatePool(env, ctx, {
- *     concurrency: 4,
+ *     concurrency: 2,
  *     tag: 'npm-install',
  *   });
  *   const results = await pool.map(
@@ -273,11 +281,11 @@ export declare class IsolatePool {
      * across pool dispatches (cache-key stability).
      */
     private readonly wasmModules;
-    /** Hash of (name + byte length + first/last bytes) of every wasm
-     *  module, folded into the loader cache key so changes invalidate
-     *  warm slots. Hashing the FULL bytes would be O(20+ MiB) per dispatch
-     *  and is unnecessary — wasm bytes are pinned at deploy time, the
-     *  length+endpoints are a strong-enough fingerprint. */
+    /** Hash of every constructor-time wasm module, folded into the loader
+     *  cache key so changes invalidate warm slots: a compiled module by the
+     *  identity its host described, bytes by name + length + first/last
+     *  byte. Hashing the FULL bytes would be O(20+ MiB) per dispatch and is
+     *  unnecessary — they are pinned at deploy time. */
     private readonly wasmHash;
     /**
      * Short prefix of the owning DO's id, baked into the loader.get()

package/dist/isolate-pool.d.ts.map

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

package/dist/isolate-pool.js

@@ -7,15 +7,15 @@
  *      running 67 npm tarball extractions (cold-start dominates). We pin
  *      each job to `slot = cursor % concurrency` and use stable loader
  *      IDs `nfp:${fnHash}:slot-${i}:g${generation}`, so a pool of
- *      concurrency=4 keeps at most 4 warm isolates rather than N fresh ones.
+ *      concurrency=N keeps at most N warm isolates rather than one per job.
  *   2. **Nimbus defaults**: compatibilityDate = CF_COMPAT_DATE (matches
- *      the supervisor worker), compatibilityFlags = ['nodejs_compat'],
+ *      the supervisor worker), compatibilityFlags = GUEST_COMPAT_FLAGS,
  *      globalOutbound = undefined (inherit parent network so the facet can
  *      reach https://registry.npmjs.org without a proxy binding).
  *   3. **Supervisor autoinjection**. The pool grabs the embedder's
  *      registered supervisor entrypoint stub (see `supervisorEntrypoint` in
  *      composition.ts) and forwards it as `env.SUPERVISOR` to every facet,
- *      same pattern as git-network-facet.ts. Callers can add more bindings
+ *      same pattern as git/network-facet.ts. Callers can add more bindings
  *      via `extraBindings`.
  *   4. **Fail-loud defaults**: timeout 60s, retries 0, onError 'throw'.
  *      Caller opts in to leniency.
@@ -23,15 +23,24 @@
  * The vendored directory contains only the upstream serialization, error,
  * and binding types used by this implementation.
  */
-import { CF_COMPAT_DATE } from '@nimbus-sh/core/constants.js';
-import { hostRoute, supervisorEntrypoint } from './composition.js';
+import { CF_COMPAT_DATE, GUEST_COMPAT_FLAGS } from '@nimbus-sh/core/constants.js';
+import { supervisorEntrypoint } from './composition.js';
+import { supervisorBindingProps, supervisorLoaderKey } from './supervisor-props.js';
 import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { serializeFunction, hashSource } from './vendor/serialize.js';
-import { beginLoaderFetch, recordLoaderId, withDynamicWorkerCapNamed } from './budgets.js';
+import { beginLoaderFetch, withDynamicWorkerCapNamed } from './budgets.js';
 import { assertModuleMapWithinCodeLimit } from './budgets.js';
 import { recordFailure, setLastFacetId, getLastRpcFrame } from '@nimbus-sh/platform/oom-discriminator.js';
 import { classifyError } from '@nimbus-sh/platform/oom-classify.js';
 import { BindingError, ExecutionError, RetryExhaustedError, TimeoutError, } from './vendor/errors.js';
+import { hostWasmIdentity } from './host-wasm.js';
+/**
+ * How long one call waits, in all, for the platform to admit it after
+ * "Dynamic worker concurrency limit exceeded" (doubling from 50 ms, at most
+ * 2 s a wait). A deployed Durable Object admitted the refused batch after a
+ * 6 s pause; 15 s bounds a call that would never be admitted.
+ */
+const CAP_REFUSAL_WAIT_MS = 15_000;
 /**
  * esbuild runtime helpers re-declared at the top of every generated facet
  * module. esbuild emits `__name(fn, "fn")` wrappers around every named
@@ -99,7 +108,7 @@ export function assembleLoaderWorkerModuleSource(options) {
  * Typical use:
  *
  *   const pool = new IsolatePool(env, ctx, {
- *     concurrency: 4,
+ *     concurrency: 2,
  *     tag: 'npm-install',
  *   });
  *   const results = await pool.map(
@@ -138,11 +147,11 @@ export class IsolatePool {
      * across pool dispatches (cache-key stability).
      */
     wasmModules;
-    /** Hash of (name + byte length + first/last bytes) of every wasm
-     *  module, folded into the loader cache key so changes invalidate
-     *  warm slots. Hashing the FULL bytes would be O(20+ MiB) per dispatch
-     *  and is unnecessary — wasm bytes are pinned at deploy time, the
-     *  length+endpoints are a strong-enough fingerprint. */
+    /** Hash of every constructor-time wasm module, folded into the loader
+     *  cache key so changes invalidate warm slots: a compiled module by the
+     *  identity its host described, bytes by name + length + first/last
+     *  byte. Hashing the FULL bytes would be O(20+ MiB) per dispatch and is
+     *  unnecessary — they are pinned at deploy time. */
     wasmHash;
     /**
      * Short prefix of the owning DO's id, baked into the loader.get()
@@ -174,7 +183,7 @@ export class IsolatePool {
         }
         this.loader = loader;
         this.ctx = ctx;
-        this.concurrency = Math.max(1, opts?.concurrency ?? 4);
+        this.concurrency = Math.max(1, opts?.concurrency ?? 1);
         this.defaultTimeoutMs = opts?.timeoutMs ?? 60_000;
         this.defaultRetries = Math.max(0, opts?.retries ?? 0);
         this.tag = opts?.tag ?? 'facet';
@@ -192,15 +201,34 @@ export class IsolatePool {
         // 'esbuild_wasm') are rejected loudly because the generated worker
         // would otherwise have duplicate imports. Order is preserved.
         const wasmEntries = [];
+        const fingerprints = [];
         const seenIds = new Set();
         if (opts?.wasmModules) {
-            for (const [name, bytes] of Object.entries(opts.wasmModules)) {
-                if (!(bytes instanceof ArrayBuffer)) {
+            for (const [name, wasm] of Object.entries(opts.wasmModules)) {
+                let fingerprint;
+                if (wasm instanceof ArrayBuffer) {
+                    // Name + length + first/last byte: hashing 20+ MiB of wasm per
+                    // dispatch would be wasteful, and these bytes change only with
+                    // the deployed bundle.
+                    const u = new Uint8Array(wasm);
+                    const len = u.byteLength;
+                    fingerprint = `${name}:${len}:${len > 0 ? u[0] : 0}:${len > 0 ? u[len - 1] : 0}`;
+                }
+                else if (wasm instanceof WebAssembly.Module) {
+                    const identity = hostWasmIdentity(wasm);
+                    if (!identity) {
+                        throw new BindingError(`IsolatePool: wasmModules['${name}'] is a WebAssembly.Module nobody described; ` +
+                            'pass it through describeHostWasm (@nimbus-sh/fabric/host-wasm.js) so warm slots ' +
+                            'can be keyed by it and the code limit can count it.');
+                    }
+                    fingerprint = `${name}:host:${identity.id}:${identity.bytes}`;
+                }
+                else {
                     // Reached only when a caller broke the declared option type, so the
-                    // value is whatever it really was rather than the ArrayBuffer here.
-                    const got = bytes?.constructor?.name;
-                    throw new BindingError(`IsolatePool: wasmModules['${name}'] must be ArrayBuffer ` +
-                        `(got ${got || typeof bytes}).`);
+                    // value is whatever it really was rather than the union here.
+                    const got = wasm?.constructor?.name;
+                    throw new BindingError(`IsolatePool: wasmModules['${name}'] must be an ArrayBuffer or a WebAssembly.Module ` +
+                        `(got ${got || typeof wasm}).`);
                 }
                 const id = name.replace(/[^A-Za-z0-9_]/g, '_').replace(/^[^A-Za-z_]/, '_');
                 if (seenIds.has(id)) {
@@ -208,29 +236,12 @@ export class IsolatePool {
                         `identifier-sanitisation (id='${id}'). Pick distinct module names.`);
                 }
                 seenIds.add(id);
-                wasmEntries.push({ name, id, bytes });
+                wasmEntries.push({ name, id, wasm });
+                fingerprints.push(fingerprint);
             }
         }
         this.wasmModules = wasmEntries;
-        // Fingerprint: name + length + first/last byte of each module.
-        // Hashing 20+ MiB of wasm per dispatch would be wasteful; this
-        // fingerprint is bytes-stable for a given deployed bundle and only
-        // changes when the wasm itself changes (deploy-time event).
-        if (wasmEntries.length === 0) {
-            this.wasmHash = '0';
-        }
-        else {
-            const fp = wasmEntries
-                .map((w) => {
-                const u = new Uint8Array(w.bytes);
-                const len = u.byteLength;
-                const first = len > 0 ? u[0] : 0;
-                const last = len > 0 ? u[len - 1] : 0;
-                return `${w.name}:${len}:${first}:${last}`;
-            })
-                .join('|');
-            this.wasmHash = hashSource(fp);
-        }
+        this.wasmHash = fingerprints.length === 0 ? '0' : hashSource(fingerprints.join('|'));
         const bindings = { ...(opts?.extraBindings ?? {}) };
         this.supervisorKey = 's-none';
         if (!opts?.omitSupervisor) {
@@ -240,11 +251,11 @@ export class IsolatePool {
                 // via supervisorDoIdOverride so SUPERVISOR.* RPCs route back
                 // to the user's session DO, not the peer DO. Default to the
                 // local ctx.id (single-DO callers and the in-DO in-DO fanout path).
-                const supDoId = opts?.supervisorDoIdOverride ?? ctx.id.toString();
-                const supPid = opts?.supervisorPid ?? 0;
-                bindings.SUPERVISOR = supervisorRpc({
-                    props: { doId: supDoId, pid: supPid, route: opts?.supervisorRoute ?? hostRoute() ?? undefined },
+                const supervisor = supervisorBindingProps(ctx, opts?.supervisorPid ?? 0, {
+                    doId: opts?.supervisorDoIdOverride,
+                    route: opts?.supervisorRoute,
                 });
+                bindings.SUPERVISOR = supervisorRpc({ props: supervisor });
                 // Whatever the minted worker's env carries must be in its loader
                 // cache key — workerd's loader cache survives a DO hibernation
                 // wake while generation-strided pids (1000001 → 2000001) do not:
@@ -252,8 +263,9 @@ export class IsolatePool {
                 // the new generation still credentialed to the dead pid, and
                 // every pid-authorized RPC from it fails "process pid … does
                 // not exist". doIdShort alone cannot cover this — it changes
-                // across sessions, not across wakes of the same session.
-                this.supervisorKey = `s${supDoId.slice(0, 12)}-${supPid}`;
+                // across sessions, not across wakes of the same session. So does
+                // the instance a binding delivers mutations to, when it names one.
+                this.supervisorKey = supervisorLoaderKey(`s${supervisor.doId.slice(0, 12)}-${supervisor.pid}`, supervisor);
             }
             else {
                 // Supervisor entrypoint unavailable — running without ctx.exports
@@ -309,7 +321,7 @@ export class IsolatePool {
                     `id='${id}') collides with another per-call key. Pick distinct names.`);
             }
             seen.add(id);
-            out.push({ name, id, bytes });
+            out.push({ name, id, wasm: bytes });
         }
         return out;
     }
@@ -345,7 +357,7 @@ export class IsolatePool {
             return '0';
         const parts = [];
         for (const w of entries) {
-            const u = new Uint8Array(w.bytes);
+            const u = new Uint8Array(w.wasm);
             const len = u.byteLength;
             // djb2 over the bytes. Faster than crypto.subtle.digest at small
             // sizes, deterministic, and good enough for cache-key
@@ -372,7 +384,7 @@ export class IsolatePool {
     #buildCode(fnSource, perCallWasmEntries) {
         const workerOpts = {
             compatibilityDate: CF_COMPAT_DATE,
-            compatibilityFlags: ['nodejs_compat'],
+            compatibilityFlags: [...GUEST_COMPAT_FLAGS],
             // Inherit parent network so the facet can reach registry.npmjs.org.
             globalOutbound: undefined,
             env: this.bindings,
@@ -416,7 +428,7 @@ export class IsolatePool {
         // (matters only for human-readable diffs; workerd doesn't care).
         const modules = { 'worker.js': moduleSource };
         for (const w of allWasmEntries) {
-            modules[w.name] = { wasm: w.bytes };
+            modules[w.name] = { wasm: w.wasm };
         }
         assertModuleMapWithinCodeLimit(modules);
         return {
@@ -516,11 +528,10 @@ export class IsolatePool {
             // binding stub once the whole pool is done, which does NOT
             // invalidate any in-flight slot's entrypoint reference.
             const stub = this.loader.get(id, async () => code);
-            recordLoaderId(this.ctx, id);
             const entrypoint = stub.getEntrypoint();
             // Direct property call, awaited by this frame — bracketed, never
             // wrapped. See beginLoaderFetch for the measured DO-poisoning hazard.
-            const endFetch = beginLoaderFetch(this.ctx);
+            const endFetch = beginLoaderFetch(this.ctx, id);
             try {
                 return await invoke(entrypoint, attempt);
             }
@@ -537,6 +548,8 @@ export class IsolatePool {
         const maxAttempts = 1 + resilience.retries;
         let lastError;
         let retriedCloneRefusal = false;
+        let capRefusals = 0;
+        let capWaitedMs = 0;
         let attempt = 0;
         while (attempt < maxAttempts) {
             try {
@@ -622,6 +635,17 @@ export class IsolatePool {
                     // reverse direction. This refresh targets the stale-loader case.
                     continue;
                 }
+                if (cause === 'dynamic_worker_cap' && capWaitedMs < CAP_REFUSAL_WAIT_MS) {
+                    // The platform refused to start this call: it still counts a
+                    // worker this Durable Object's ledger has already given back (a
+                    // fan-out's workers stay counted for a moment after their calls
+                    // return). Nothing ran, so the call waits, as the platform asks,
+                    // and is sent again; it does not spend an attempt.
+                    const delay = Math.min(CAP_REFUSAL_WAIT_MS - capWaitedMs, 50 * 2 ** capRefusals++, 2000);
+                    capWaitedMs += delay;
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                    continue;
+                }
                 if (attempt < maxAttempts - 1) {
                     // 100 * 2^attempt, capped at 2s so retries don't compound waiting.
                     const delay = Math.min(2000, 100 * Math.pow(2, attempt));
@@ -630,9 +654,9 @@ export class IsolatePool {
                 attempt++;
             }
         }
-        // On the way out only, so retries do not stack the annotation: a cap hit
-        // carries the ledger — which ids hold slots, and that a keyed id never
-        // gives one back — instead of the platform's bare message.
+        // On the way out only, so retries do not stack the annotation: a limit
+        // hit carries the ledger — which workers were in flight — instead of the
+        // platform's bare message.
         const named = withDynamicWorkerCapNamed(this.ctx, lastError);
         if (maxAttempts > 1) {
             throw new RetryExhaustedError(maxAttempts, named);