@nimbus-sh/fabric 0.4.0 → 0.5.0

package/dist/generation.d.ts

@@ -14,6 +14,12 @@
  * counter, and bumps it once. The embedder reads `generation(ctx)` wherever it
  * needs the incarnation number — one source of truth instead of mirrored host
  * fields.
+ *
+ * This is also the allocator for a workspace's generation: an embedder
+ * composing NimbusWorkspace over its own Durable Object calls
+ * `adoptGeneration(ctx)` once per incarnation and passes `generation(ctx)`
+ * as the workspace's `generation` — the same persisted counter the session
+ * derives its pid generation from, so there is no second counter to keep.
  */
 /**
  * Storage key for the isolate-generation counter (cold-start +

package/dist/generation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generation.d.ts","sourceRoot":"","sources":["../src/generation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAE/C,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAsBD,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,yEAAyE;AACzE,wBAAsB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B3E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAIjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAE3E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYvD"}
+{"version":3,"file":"generation.d.ts","sourceRoot":"","sources":["../src/generation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAE/C,2DAA2D;AAC3D,MAAM,WAAW,iBAAiB;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjD;AAED,qEAAqE;AACrE,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAsBD,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,yEAAyE;AACzE,wBAAsB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B3E;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAIjE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAE3E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYvD"}

package/dist/generation.js

@@ -14,6 +14,12 @@
  * counter, and bumps it once. The embedder reads `generation(ctx)` wherever it
  * needs the incarnation number — one source of truth instead of mirrored host
  * fields.
+ *
+ * This is also the allocator for a workspace's generation: an embedder
+ * composing NimbusWorkspace over its own Durable Object calls
+ * `adoptGeneration(ctx)` once per incarnation and passes `generation(ctx)`
+ * as the workspace's `generation` — the same persisted counter the session
+ * derives its pid generation from, so there is no second counter to keep.
  */
 import { errorText } from '@nimbus-sh/core/_shared/error-text.js';
 /**

package/dist/image-store.d.ts

@@ -92,10 +92,20 @@ export declare class ImageStore {
      * Materialize generated module sources in the content-addressed image store
      * and return the module-name → path map naming them.
      *
+     * Takes the images as a SEQUENCE, produced on demand and released as each
+     * one's slices land, so exactly one image's text is resident here. The old
+     * record-shaped parameter held every source for the whole call, and the
+     * caller held its own copy beside it: measured on a real-vite launch, the
+     * second image reported not one slice — ~25 MB of module text as UTF-16 in
+     * two places, plus the first image's just-freed 10.36 MB encode buffer, on a
+     * 128 MiB isolate. Yielding and dropping is what makes the peak one image
+     * instead of all of them; it is not a pacing question, and a fresh turn does
+     * not shrink a live heap.
+     *
      * 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, modules: Record<string, string>, pacer: TurnBudget): Promise<Record<string, string>>;
+    materialize(pid: number, images: AsyncIterable<readonly [string, string]> | Iterable<readonly [string, 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;;;;;;OAMG;IACG,WAAW,CACf,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/B,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAoDlC;;;;;;;;;;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,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"}

package/dist/image-store.js

@@ -84,32 +84,42 @@ export class ImageStore {
      * Materialize generated module sources in the content-addressed image store
      * and return the module-name → path map naming them.
      *
+     * Takes the images as a SEQUENCE, produced on demand and released as each
+     * one's slices land, so exactly one image's text is resident here. The old
+     * record-shaped parameter held every source for the whole call, and the
+     * caller held its own copy beside it: measured on a real-vite launch, the
+     * second image reported not one slice — ~25 MB of module text as UTF-16 in
+     * two places, plus the first image's just-freed 10.36 MB encode buffer, on a
+     * 128 MiB isolate. Yielding and dropping is what makes the peak one image
+     * instead of all of them; it is not a pacing question, and a fresh turn does
+     * not shrink a live heap.
+     *
      * Writing the sources here, once, is what lets the session stop holding
      * them: after this returns, the only thing it keeps is a path.
      */
-    async materialize(pid, modules, pacer) {
+    async materialize(pid, images, pacer) {
         const fs = this.blobs();
-        const images = {};
-        const sources = new Map();
-        for (const [moduleName, source] of Object.entries(modules)) {
-            const path = facetImagePath(await facetImageDigest(source));
-            images[moduleName] = path;
-            sources.set(path, source);
-            await pacer.spend(source.length);
-        }
-        // Register the WHOLE root set here, in one synchronous step, before any
-        // byte of it exists on disk. That ordering is the entire protocol between
-        // a launch and the sweep: an image is rooted from before it is written, so
-        // a sweep can never observe a file this launch has written but not yet
-        // claimed. The old loop achieved it by not awaiting at all, which read as
-        // "the writes must not be interrupted" — they may be. What must not be
-        // interrupted is the gap between writing and rooting, and rooting first
-        // closes it for every write that follows, however many turns they span.
-        this.residentImages.set(pid, [...sources.keys()]);
+        const paths = {};
+        // The root set is this ARRAY, held by the sweep's map from before the
+        // first byte and appended to as each image is named. Rooting an image
+        // before its own first byte is the whole of the protocol: a sweep that
+        // runs while this launch is suspended sees every image already written as
+        // rooted, and an image not yet written is not yet a file. The array
+        // identity is what makes an append visible — do not replace it.
+        const rooted = [];
+        this.residentImages.set(pid, rooted);
         fs.mkdirp(FACET_IMAGE_DIR);
-        for (const [path, source] of sources) {
+        let count = 0;
+        for await (const [moduleName, source] of images) {
+            const path = facetImagePath(await facetImageDigest(source));
+            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);
             // An image at its full size is a COMPLETE one: a write only ever grows
             // the file from offset zero, so a write cut short by a reset leaves a
             // strictly shorter file and fails this test. Size is enough of a check
@@ -138,7 +148,8 @@ export class ImageStore {
             } while (offset < bytes.byteLength);
         }
         this.sweep(fs);
-        return images;
+        console.log('[image-store] pid=' + pid + ' materialized ' + count + ' image(s) in ' + pacer.chunks + ' turn(s)');
+        return paths;
     }
     /**
      * Drop every image no running process boots from.

package/dist/isolate-pool.d.ts

@@ -235,6 +235,18 @@ export declare class IsolatePool {
     private readonly defaultRetries;
     private readonly tag;
     private readonly slotGenerations;
+    /**
+     * Per-slot execution ownership: the tail of each slot's in-flight
+     * dispatch chain. Two dispatches on the same warm isolate at once
+     * interleave on its QueueState — map() callers used to trust the
+     * caller's slot round-robin, which could not prevent submit() (slot
+     * 0) or a second map() landing on a slot a task still occupied. Every
+     * dispatch now waits for the slot's previous execution to settle
+     * before touching it.
+     */
+    private readonly slotTails;
+    /** Set by dispose() — queued dispatches reject instead of running. */
+    private disposed;
     private bindings;
     private readonly preamble;
     private readonly preambleHash;
@@ -262,6 +274,13 @@ export declare class IsolatePool {
      * 12 chars is enough entropy for DO ids to collide-free per process.
      */
     private readonly doIdShort;
+    /**
+     * The supervisor identity the minted worker's env.SUPERVISOR binding
+     * bakes (doId short-form + pid), folded into the loader cache key. 's-none'
+     * when no SUPERVISOR binding was minted, so a supervisor-less pool keeps
+     * the old key shape and its warm slots stay shared.
+     */
+    private readonly supervisorKey;
     constructor(env: unknown, ctx: DurableObjectState, opts?: IsolatePoolOptions);
     /** Effective concurrency used when no per-call override is supplied. */
     get defaultConcurrency(): number;

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

@@ -113,6 +113,18 @@ export class IsolatePool {
     defaultRetries;
     tag;
     slotGenerations = new Map();
+    /**
+     * Per-slot execution ownership: the tail of each slot's in-flight
+     * dispatch chain. Two dispatches on the same warm isolate at once
+     * interleave on its QueueState — map() callers used to trust the
+     * caller's slot round-robin, which could not prevent submit() (slot
+     * 0) or a second map() landing on a slot a task still occupied. Every
+     * dispatch now waits for the slot's previous execution to settle
+     * before touching it.
+     */
+    slotTails = new Map();
+    /** Set by dispose() — queued dispatches reject instead of running. */
+    disposed = false;
     bindings;
     preamble;
     preambleHash;
@@ -140,6 +152,13 @@ export class IsolatePool {
      * 12 chars is enough entropy for DO ids to collide-free per process.
      */
     doIdShort;
+    /**
+     * The supervisor identity the minted worker's env.SUPERVISOR binding
+     * bakes (doId short-form + pid), folded into the loader cache key. 's-none'
+     * when no SUPERVISOR binding was minted, so a supervisor-less pool keeps
+     * the old key shape and its warm slots stay shared.
+     */
+    supervisorKey;
     constructor(env, ctx, opts) {
         // A host hands its whole env over; the binding is claimed here and the
         // claim is checked on the next line.
@@ -207,6 +226,7 @@ export class IsolatePool {
             this.wasmHash = hashSource(fp);
         }
         const bindings = { ...(opts?.extraBindings ?? {}) };
+        this.supervisorKey = 's-none';
         if (!opts?.omitSupervisor) {
             const supervisorRpc = supervisorEntrypoint();
             if (supervisorRpc) {
@@ -215,9 +235,19 @@ export class IsolatePool {
                 // 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: opts?.supervisorPid ?? 0 },
+                    props: { doId: supDoId, pid: supPid },
                 });
+                // 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:
+                // a warm slot keyed without the supervisor identity returns in
+                // 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}`;
             }
             else {
                 // Supervisor entrypoint unavailable — running without ctx.exports
@@ -398,8 +428,35 @@ export class IsolatePool {
     /**
      * Dispatch a single task to the slot isolate. `slotIndex` picks which
      * warm isolate services the call; callers round-robin slots themselves.
+     * Serialized per slot: this call waits for the slot's previous
+     * execution to settle before touching the warm isolate.
      */
     async #dispatchSlot(fnSource, fnHash, slotIndex, args, resilience, perCallWasm) {
+        // A warm slot executes one dispatch at a time: queue behind the
+        // previous owner, then record this dispatch as the new tail. The
+        // tail outlives the caller's outcome: a timeout rejects the
+        // Promise.race while runOnce's RPC is still live on the Worker, so
+        // release waits for every execution the owned body started to
+        // settle — never the caller's settle alone.
+        const previous = this.slotTails.get(slotIndex) ?? Promise.resolve();
+        let release;
+        this.slotTails.set(slotIndex, new Promise((resolve) => { release = resolve; }));
+        await previous;
+        if (this.disposed) {
+            release();
+            throw new BindingError(`IsolatePool(${this.tag}) is disposed`);
+        }
+        const inFlight = [];
+        try {
+            return await this.#dispatchSlotOwned(fnSource, fnHash, slotIndex, args, resilience, perCallWasm, inFlight);
+        }
+        finally {
+            // Do not delay the caller's own outcome — the tail releases when
+            // the RPCs the body launched have actually settled.
+            void Promise.allSettled(inFlight).then(() => release());
+        }
+    }
+    async #dispatchSlotOwned(fnSource, fnHash, slotIndex, args, resilience, perCallWasm, inFlight) {
         // Per-call wasm fingerprint. Mixed into the cache key so two calls
         // with different bytes hit different slots (no cache poisoning).
         // For the common case (no per-call wasm) the fingerprint is '0',
@@ -407,11 +464,11 @@ export class IsolatePool {
         const perCallWasmEntries = this.#materialisePerCallWasm(perCallWasm);
         const perCallWasmHash = this.#fingerprintWasm(perCallWasmEntries);
         // Cache key includes the short DO id so warm isolates are scoped to
-        // ONE session. See the doIdShort field comment for why — without it,
-        // a later session's pool reuses the warm worker from a previous
-        // session (which still carries the old session's env.SUPERVISOR
-        // binding), and writeBatch RPCs land in the wrong DO's VFS.
-        const buildId = (generation) => `nfp:${this.tag}:${this.doIdShort}:${fnHash}:${this.preambleHash}:${this.wasmHash}:${perCallWasmHash}:slot-${slotIndex}:g${generation}`;
+        // ONE session (see the doIdShort field comment), and the supervisor
+        // identity so a wake of that same session can never reuse a warm
+        // worker whose SUPERVISOR binding still names the dead generation's
+        // pid. See the supervisorKey field comment for the failure mode.
+        const buildId = (generation) => `nfp:${this.tag}:${this.doIdShort}:${fnHash}:${this.preambleHash}:${this.wasmHash}:${perCallWasmHash}:${this.supervisorKey}:slot-${slotIndex}:g${generation}`;
         let id = buildId(this.slotGenerations.get(slotIndex) ?? 0);
         const code = this.#buildCode(fnSource, perCallWasmEntries);
         // W5 Lever 5: record the dispatch so /api/_diag/memory shows the
@@ -489,8 +546,10 @@ export class IsolatePool {
                     // See plan in close-plan-2026-04-28.
                     let timerId;
                     try {
+                        const attemptPromise = runOnce();
+                        inFlight.push(attemptPromise);
                         return await Promise.race([
-                            runOnce(),
+                            attemptPromise,
                             new Promise((_, reject) => {
                                 timerId = setTimeout(() => reject(new TimeoutError(resilience.timeoutMs)), resilience.timeoutMs);
                             }),
@@ -501,7 +560,9 @@ export class IsolatePool {
                             clearTimeout(timerId);
                     }
                 }
-                return await runOnce();
+                const attemptPromise = runOnce();
+                inFlight.push(attemptPromise);
+                return await attemptPromise;
             }
             catch (err) {
                 lastError = err instanceof Error ? err : new Error(String(err));
@@ -655,6 +716,7 @@ export class IsolatePool {
      * Safe to call more than once; idempotent.
      */
     dispose() {
+        this.disposed = true;
         if (!this.bindings)
             return;
         for (const key of Object.keys(this.bindings)) {

package/dist/turn-budget.d.ts

@@ -58,10 +58,10 @@ export declare const TURN_CHUNK_MAX_BYTES = 2000000;
  * spent.
  *
  * Callers report the work they are about to do or have just done and await
- * the result; a pacer that is not yielding returns without suspending, so the
- * one-shot exec path — which passes no pacer at all — keeps its exact
- * behaviour and cost. Nothing here decides WHAT the launch does, only where it
- * is allowed to stop.
+ * the result; a pacer that is not yielding returns without suspending, so a
+ * build small enough to fit in one chunk — most one-shot execs, every cache
+ * hit — keeps its exact behaviour and cost. Nothing here decides WHAT the
+ * launch does, only where it is allowed to stop.
  */
 export declare class TurnBudget {
     private readonly scheduler;

package/dist/turn-budget.js

@@ -47,10 +47,10 @@ export const TURN_CHUNK_MAX_BYTES = 2_000_000;
  * spent.
  *
  * Callers report the work they are about to do or have just done and await
- * the result; a pacer that is not yielding returns without suspending, so the
- * one-shot exec path — which passes no pacer at all — keeps its exact
- * behaviour and cost. Nothing here decides WHAT the launch does, only where it
- * is allowed to stop.
+ * the result; a pacer that is not yielding returns without suspending, so a
+ * build small enough to fit in one chunk — most one-shot execs, every cache
+ * hit — keeps its exact behaviour and cost. Nothing here decides WHAT the
+ * launch does, only where it is allowed to stop.
  */
 export class TurnBudget {
     scheduler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nimbus-sh/fabric",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "The Cloudflare half of Nimbus — Durable Object facet hosting, dynamic-worker loader pools, the resident-process fabric, and DO alarm/hibernation machinery.",
   "keywords": [
     "cloudflare",
@@ -50,8 +50,8 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@nimbus-sh/core": "^0.8.0",
-    "@nimbus-sh/platform": "^0.3.0",
+    "@nimbus-sh/core": "^0.9.0",
+    "@nimbus-sh/platform": "^0.4.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {

package/src/generation.ts

@@ -14,6 +14,12 @@
  * counter, and bumps it once. The embedder reads `generation(ctx)` wherever it
  * needs the incarnation number — one source of truth instead of mirrored host
  * fields.
+ *
+ * This is also the allocator for a workspace's generation: an embedder
+ * composing NimbusWorkspace over its own Durable Object calls
+ * `adoptGeneration(ctx)` once per incarnation and passes `generation(ctx)`
+ * as the workspace's `generation` — the same persisted counter the session
+ * derives its pid generation from, so there is no second counter to keep.
  */
 
 import { errorText } from '@nimbus-sh/core/_shared/error-text.js';

package/src/image-store.ts

@@ -107,36 +107,48 @@ export class ImageStore {
    * Materialize generated module sources in the content-addressed image store
    * and return the module-name → path map naming them.
    *
+   * Takes the images as a SEQUENCE, produced on demand and released as each
+   * one's slices land, so exactly one image's text is resident here. The old
+   * record-shaped parameter held every source for the whole call, and the
+   * caller held its own copy beside it: measured on a real-vite launch, the
+   * second image reported not one slice — ~25 MB of module text as UTF-16 in
+   * two places, plus the first image's just-freed 10.36 MB encode buffer, on a
+   * 128 MiB isolate. Yielding and dropping is what makes the peak one image
+   * instead of all of them; it is not a pacing question, and a fresh turn does
+   * not shrink a live heap.
+   *
    * Writing the sources here, once, is what lets the session stop holding
    * them: after this returns, the only thing it keeps is a path.
    */
   async materialize(
     pid: number,
-    modules: Record<string, string>,
+    images: AsyncIterable<readonly [string, string]> | Iterable<readonly [string, string]>,
     pacer: TurnBudget,
   ): Promise<Record<string, string>> {
     const fs = this.blobs();
-    const images: Record<string, string> = {};
-    const sources = new Map<string, string>();
-    for (const [moduleName, source] of Object.entries(modules)) {
-      const path = facetImagePath(await facetImageDigest(source));
-      images[moduleName] = path;
-      sources.set(path, source);
-      await pacer.spend(source.length);
-    }
-    // Register the WHOLE root set here, in one synchronous step, before any
-    // byte of it exists on disk. That ordering is the entire protocol between
-    // a launch and the sweep: an image is rooted from before it is written, so
-    // a sweep can never observe a file this launch has written but not yet
-    // claimed. The old loop achieved it by not awaiting at all, which read as
-    // "the writes must not be interrupted" — they may be. What must not be
-    // interrupted is the gap between writing and rooting, and rooting first
-    // closes it for every write that follows, however many turns they span.
-    this.residentImages.set(pid, [...sources.keys()]);
+    const paths: Record<string, string> = {};
+    // The root set is this ARRAY, held by the sweep's map from before the
+    // first byte and appended to as each image is named. Rooting an image
+    // before its own first byte is the whole of the protocol: a sweep that
+    // runs while this launch is suspended sees every image already written as
+    // rooted, and an image not yet written is not yet a file. The array
+    // identity is what makes an append visible — do not replace it.
+    const rooted: string[] = [];
+    this.residentImages.set(pid, rooted);
     fs.mkdirp(FACET_IMAGE_DIR);
-    for (const [path, source] of sources) {
+    let count = 0;
+    for await (const [moduleName, source] of images) {
+      const path = facetImagePath(await facetImageDigest(source));
+      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,
+      );
       // An image at its full size is a COMPLETE one: a write only ever grows
       // the file from offset zero, so a write cut short by a reset leaves a
       // strictly shorter file and fails this test. Size is enough of a check
@@ -163,7 +175,8 @@ export class ImageStore {
       } while (offset < bytes.byteLength);
     }
     this.sweep(fs);
-    return images;
+    console.log('[image-store] pid=' + pid + ' materialized ' + count + ' image(s) in ' + pacer.chunks + ' turn(s)');
+    return paths;
   }
 
   /**

package/src/isolate-pool.ts

@@ -345,6 +345,18 @@ export class IsolatePool {
   private readonly defaultRetries: number;
   private readonly tag: string;
   private readonly slotGenerations = new Map<number, number>();
+  /**
+   * Per-slot execution ownership: the tail of each slot's in-flight
+   * dispatch chain. Two dispatches on the same warm isolate at once
+   * interleave on its QueueState — map() callers used to trust the
+   * caller's slot round-robin, which could not prevent submit() (slot
+   * 0) or a second map() landing on a slot a task still occupied. Every
+   * dispatch now waits for the slot's previous execution to settle
+   * before touching it.
+   */
+  private readonly slotTails = new Map<number, Promise<void>>();
+  /** Set by dispose() — queued dispatches reject instead of running. */
+  private disposed = false;
   private bindings: Record<string, unknown> | undefined;
 
   private readonly preamble: string | undefined;
@@ -380,6 +392,13 @@ export class IsolatePool {
    * 12 chars is enough entropy for DO ids to collide-free per process.
    */
   private readonly doIdShort: string;
+  /**
+   * The supervisor identity the minted worker's env.SUPERVISOR binding
+   * bakes (doId short-form + pid), folded into the loader cache key. 's-none'
+   * when no SUPERVISOR binding was minted, so a supervisor-less pool keeps
+   * the old key shape and its warm slots stay shared.
+   */
+  private readonly supervisorKey: string;
 
   constructor(
     env: unknown,
@@ -459,6 +478,7 @@ export class IsolatePool {
     }
 
     const bindings: Record<string, unknown> = { ...(opts?.extraBindings ?? {}) };
+    this.supervisorKey = 's-none';
     if (!opts?.omitSupervisor) {
       const supervisorRpc = supervisorEntrypoint();
       if (supervisorRpc) {
@@ -467,9 +487,19 @@ export class IsolatePool {
         // 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: opts?.supervisorPid ?? 0 },
+          props: { doId: supDoId, pid: supPid },
         });
+        // 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:
+        // a warm slot keyed without the supervisor identity returns in
+        // 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}`;
       } else {
         // Supervisor entrypoint unavailable — running without ctx.exports
         // (e.g. unit-test harness, or LOADER.load contexts where the
@@ -669,6 +699,8 @@ export class IsolatePool {
   /**
    * Dispatch a single task to the slot isolate. `slotIndex` picks which
    * warm isolate services the call; callers round-robin slots themselves.
+   * Serialized per slot: this call waits for the slot's previous
+   * execution to settle before touching the warm isolate.
    */
   async #dispatchSlot(
     fnSource: string,
@@ -677,6 +709,39 @@ export class IsolatePool {
     args: unknown[],
     resilience: ResolvedResilience,
     perCallWasm?: Record<string, ArrayBuffer>,
+  ): Promise<unknown> {
+    // A warm slot executes one dispatch at a time: queue behind the
+    // previous owner, then record this dispatch as the new tail. The
+    // tail outlives the caller's outcome: a timeout rejects the
+    // Promise.race while runOnce's RPC is still live on the Worker, so
+    // release waits for every execution the owned body started to
+    // settle — never the caller's settle alone.
+    const previous = this.slotTails.get(slotIndex) ?? Promise.resolve();
+    let release: () => void;
+    this.slotTails.set(slotIndex, new Promise<void>((resolve) => { release = resolve; }));
+    await previous;
+    if (this.disposed) {
+      release!();
+      throw new BindingError(`IsolatePool(${this.tag}) is disposed`);
+    }
+    const inFlight: Promise<unknown>[] = [];
+    try {
+      return await this.#dispatchSlotOwned(fnSource, fnHash, slotIndex, args, resilience, perCallWasm, inFlight);
+    } finally {
+      // Do not delay the caller's own outcome — the tail releases when
+      // the RPCs the body launched have actually settled.
+      void Promise.allSettled(inFlight).then(() => release!());
+    }
+  }
+
+  async #dispatchSlotOwned(
+    fnSource: string,
+    fnHash: string,
+    slotIndex: number,
+    args: unknown[],
+    resilience: ResolvedResilience,
+    perCallWasm: Record<string, ArrayBuffer> | undefined,
+    inFlight: Promise<unknown>[],
   ): Promise<unknown> {
     // Per-call wasm fingerprint. Mixed into the cache key so two calls
     // with different bytes hit different slots (no cache poisoning).
@@ -686,12 +751,12 @@ export class IsolatePool {
     const perCallWasmHash = this.#fingerprintWasm(perCallWasmEntries);
 
     // Cache key includes the short DO id so warm isolates are scoped to
-    // ONE session. See the doIdShort field comment for why — without it,
-    // a later session's pool reuses the warm worker from a previous
-    // session (which still carries the old session's env.SUPERVISOR
-    // binding), and writeBatch RPCs land in the wrong DO's VFS.
+    // ONE session (see the doIdShort field comment), and the supervisor
+    // identity so a wake of that same session can never reuse a warm
+    // worker whose SUPERVISOR binding still names the dead generation's
+    // pid. See the supervisorKey field comment for the failure mode.
     const buildId = (generation: number): string =>
-      `nfp:${this.tag}:${this.doIdShort}:${fnHash}:${this.preambleHash}:${this.wasmHash}:${perCallWasmHash}:slot-${slotIndex}:g${generation}`;
+      `nfp:${this.tag}:${this.doIdShort}:${fnHash}:${this.preambleHash}:${this.wasmHash}:${perCallWasmHash}:${this.supervisorKey}:slot-${slotIndex}:g${generation}`;
     let id = buildId(this.slotGenerations.get(slotIndex) ?? 0);
     const code = this.#buildCode(fnSource, perCallWasmEntries);
 
@@ -767,8 +832,10 @@ export class IsolatePool {
           // See plan in close-plan-2026-04-28.
           let timerId: ReturnType<typeof setTimeout> | undefined;
           try {
+            const attemptPromise = runOnce();
+            inFlight.push(attemptPromise);
             return await Promise.race([
-              runOnce(),
+              attemptPromise,
               new Promise<never>((_, reject) => {
                 timerId = setTimeout(
                   () => reject(new TimeoutError(resilience.timeoutMs)),
@@ -780,7 +847,9 @@ export class IsolatePool {
             if (timerId !== undefined) clearTimeout(timerId);
           }
         }
-        return await runOnce();
+        const attemptPromise = runOnce();
+        inFlight.push(attemptPromise);
+        return await attemptPromise;
       } catch (err) {
         lastError = err instanceof Error ? err : new Error(String(err));
         const cause = classifyError(lastError);
@@ -974,6 +1043,7 @@ export class IsolatePool {
    * Safe to call more than once; idempotent.
    */
   dispose(): void {
+    this.disposed = true;
     if (!this.bindings) return;
     for (const key of Object.keys(this.bindings)) {
       disposeRpcResource(this.bindings[key]);

package/src/turn-budget.ts

@@ -63,10 +63,10 @@ export const TURN_CHUNK_MAX_BYTES = 2_000_000;
  * spent.
  *
  * Callers report the work they are about to do or have just done and await
- * the result; a pacer that is not yielding returns without suspending, so the
- * one-shot exec path — which passes no pacer at all — keeps its exact
- * behaviour and cost. Nothing here decides WHAT the launch does, only where it
- * is allowed to stop.
+ * the result; a pacer that is not yielding returns without suspending, so a
+ * build small enough to fit in one chunk — most one-shot execs, every cache
+ * hit — keeps its exact behaviour and cost. Nothing here decides WHAT the
+ * launch does, only where it is allowed to stop.
  */
 export class TurnBudget {
   /** Turn handoffs this launch has taken. Reported with the launch. */