knitting 0.1.60 → 0.1.61

package/src/memory/regionRegistry.js

@@ -4,7 +4,7 @@ import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
 // Low 5 bits = slot index, high 27 bits = caller meta.
 // Inlined from setTaskSlotIndex to avoid cross-closure call on hot path.
 const SLOT_META_PACKED_MASK = 0xFFFFFFE0; // (~0x1F) >>> 0
-export const register = ({ lockSector, publishMode = "plain", }) => {
+export const register = ({ lockSector, }) => {
     const lockRegion = toSharedBufferRegion(lockSector ?? createWasmSharedArrayBuffer(LOCK_SECTOR_BYTE_LENGTH));
     const lockSAB = lockRegion.sab;
     const hostBits = new Int32Array(lockSAB, lockRegion.byteOffset + PAYLOAD_LOCK_HOST_BITS_OFFSET_BYTES, 1);
@@ -14,7 +14,7 @@ export const register = ({ lockSector, publishMode = "plain", }) => {
     const clz32 = Math.clz32;
     const a_load = Atomics.load;
     const a_store = Atomics.store;
-    const useAtomicPublish = publishMode === "atomic";
+    const a_xor = Atomics.xor;
     const EMPTY = 0xFFFFFFFF >>> 0;
     const SLOT_MASK = TASK_SLOT_INDEX_MASK;
     const START_MASK = (~SLOT_MASK) >>> 0;
@@ -23,7 +23,6 @@ export const register = ({ lockSector, publishMode = "plain", }) => {
     let usedBits = 0 | 0;
     // scalar state (faster than Uint32Array(1))
     let hostLast = 0 | 0;
-    let workerLast = 0 | 0;
     const startAndIndexToArray = (length) => startAndIndex.slice(0, length);
     const compactFreeBitsStable = (b, freeBits) => {
         const sai = startAndIndex;
@@ -92,10 +91,14 @@ export const register = ({ lockSector, publishMode = "plain", }) => {
             let freeBits = (~(hostLast ^ w)) >>> 0;
             if (freeBits !== 0)
                 freeBits &= usedBits;
-            if (freeBits === EMPTY) {
+            // Every tracked slot is free, so restart the arena from offset 0. A free
+            // racing after this snapshot can only delay reclamation until the next
+            // allocation; it cannot make a live slot appear free.
+            if (freeBits === (usedBits >>> 0)) {
                 tableLength = 0;
                 usedBits = 0 | 0;
                 tl = 0;
+                freeBits = 0 >>> 0;
             }
             else if (freeBits !== 0) {
                 for (let i = 0; i < tl; i++) {
@@ -247,10 +250,7 @@ export const register = ({ lockSector, publishMode = "plain", }) => {
         const slotIndex = findAndInsert(task, size);
         if (slotIndex === -1)
             return -1;
-        if (useAtomicPublish)
-            a_store(hostBits, 0, hostLast);
-        else
-            hostBits[0] = hostLast;
+        a_store(hostBits, 0, hostLast);
         return slotIndex;
     };
     const setSlotLength = (slotIndex, payloadLen) => {
@@ -264,13 +264,15 @@ export const register = ({ lockSector, publishMode = "plain", }) => {
         size64bit[slotIndex] = aligned >>> 0;
         return true;
     };
+    // Always a read-modify-write. `free()` genuinely has two callers even without
+    // work stealing: the encode-side rollback (`failDynamicWriteAfterReserve`)
+    // and the decode-side release (`freeTaskSlot`). Each held a private
+    // `workerLast` shadow and blind-stored the whole word, so one overwrote the
+    // other's toggles — the allocator then handed out a region that was still
+    // live, aliasing payloads. XOR of distinct bits commutes, so one atomic
+    // toggle per free is correct for any number of writers.
     const free = (index) => {
-        index = index & TASK_SLOT_INDEX_MASK;
-        workerLast ^= 1 << index;
-        if (useAtomicPublish)
-            a_store(workerBits, 0, workerLast);
-        else
-            workerBits[0] = workerLast;
+        a_xor(workerBits, 0, 1 << (index & TASK_SLOT_INDEX_MASK));
     };
     return {
         allocTask,

package/src/permission/protocol.js

@@ -1,4 +1,4 @@
-import { RUNTIME } from "../common/runtime.js";
+import { IS_BROWSER, RUNTIME } from "../common/runtime.js";
 import { toCanonicalPath as toSharedCanonicalPath } from "../common/path-canonical.js";
 import { getNodeBuiltinModule, getNodeProcess } from "../common/node-compat.js";
 const requireNodeModule = (specifier) => {
@@ -436,6 +436,10 @@ export const resolvePermissionProtocol = ({ permission, modules, }) => {
     const input = normalizeProtocolInput(permission);
     if (!input)
         return undefined;
+    // Browsers have no filesystem, process, or runtime flags to police, and the
+    // strict default would otherwise reach for `node:path` and throw.
+    if (IS_BROWSER)
+        return undefined;
     const rawMode = input.mode;
     const mode = (rawMode === "unsafe" || rawMode === "off")
         ? "unsafe"

package/src/runtime/dispatcher.js

@@ -24,6 +24,15 @@ export const hostDispatcherLoop = ({ signalBox: { opView, txStatus, rxStatus, },
             check.rerun = true;
             return;
         }
+        // Nothing enqueued and nothing outstanding at the worker: skip the drain.
+        // Without this an idle lane still pays a txStatus write, an rxStatus load
+        // and — worst of all — an Atomics.notify that wakes a parked worker for no
+        // reason. Under the serial-channel dispatcher every lane is checked on
+        // every tick, so that waste is what makes latency grow with thread count.
+        if (txIdle()) {
+            check.isRunning = false;
+            return;
+        }
         inFlight = true;
         if (backoffTimer !== undefined) {
             clearTimeout(backoffTimer);

package/src/runtime/pool.d.ts

@@ -1,12 +1,104 @@
+import { createHostTxQueue } from "./tx-queue.js";
 import { type ProcessSharedMemoryBacking } from "./process-worker.js";
 import { type Sab } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, type DispatcherCheck } from "./dispatcher.js";
-import { lock2 } from "../memory/lock.js";
+import { lock2, type Task } from "../memory/lock.js";
 import "../memory/payloadCodec.js";
-import type { DebugOptions, DispatcherSettings, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
+import type { DebugOptions, DispatcherSettings, LockBuffers, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
 import "../worker/loop.js";
 import { type PayloadBufferOptions } from "../memory/payload-config.js";
-export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, }: {
+/**
+ * Build the buffers, host-side locks and pending registry that a stealing pool
+ * shares. One submit region for every worker to claim from, one private return
+ * region per worker, and a single pool-global queue so a response arriving on
+ * any lane settles the right promise.
+ *
+ * Region width follows paper §6.1: the largest power-of-two `g` leaving a spare
+ * region for a delayed claimant (`slots / g >= consumers + 1`). At 32 slots that
+ * caps how wide a region can be well before it caps the worker count.
+ */
+export declare const resolveStealRegionLanes: (consumers: number) => number;
+/** Maximum claimants that leave the protocol's required spare region. */
+export declare const MAX_STEAL_CONSUMERS: number;
+export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, abortSignalCapacity, usesAbortSignal, }: {
+    threads: number;
+    payload?: PayloadBufferOptions;
+    regionLanes?: number;
+    abortSignalCapacity?: number;
+    usesAbortSignal?: boolean;
+}) => {
+    submitBuffers: LockBuffers;
+    returnBuffers: LockBuffers[];
+    hostSubmitLock: {
+        enlist: (task: Task) => true;
+        encode: (task: Task, state?: number) => boolean;
+        encodeManyFrom: (list: import("../ipc/tools/ring-queue.js").default<Task>) => number;
+        encodeAll: () => boolean;
+        publish: (task: Task) => boolean;
+        flushPending: () => boolean;
+        decode: () => boolean;
+        hasSpace: () => boolean;
+        resolved: import("../ipc/tools/ring-queue.js").default<Task>;
+        hostBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        workerBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        recyclecList: import("../ipc/tools/ring-queue.js").default<Task>;
+        resolveHost: ({ queue, onResolved, shouldSettle, activeRejectPlaceholder, }: {
+            queue: Task[];
+            onResolved?: (task: Task) => void;
+            shouldSettle?: (task: Task) => boolean;
+            activeRejectPlaceholder?: Task["reject"];
+        }) => () => number;
+        hasPendingFrames: () => boolean;
+        getPendingFrameCount: () => number;
+        getPendingPromiseCount: () => number;
+        resetPendingState: () => void;
+        deactivateStealConsumer: (id: number) => boolean;
+        takeDeferredCount: () => number;
+        setPromiseHandler: (handler?: import("../memory/lock.js").PromisePayloadHandler) => void;
+    };
+    hostReturnLocks: {
+        enlist: (task: Task) => true;
+        encode: (task: Task, state?: number) => boolean;
+        encodeManyFrom: (list: import("../ipc/tools/ring-queue.js").default<Task>) => number;
+        encodeAll: () => boolean;
+        publish: (task: Task) => boolean;
+        flushPending: () => boolean;
+        decode: () => boolean;
+        hasSpace: () => boolean;
+        resolved: import("../ipc/tools/ring-queue.js").default<Task>;
+        hostBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        workerBits: Int32Array<import("../common/shared-buffer-region.js").SharedBuffer>;
+        recyclecList: import("../ipc/tools/ring-queue.js").default<Task>;
+        resolveHost: ({ queue, onResolved, shouldSettle, activeRejectPlaceholder, }: {
+            queue: Task[];
+            onResolved?: (task: Task) => void;
+            shouldSettle?: (task: Task) => boolean;
+            activeRejectPlaceholder?: Task["reject"];
+        }) => () => number;
+        hasPendingFrames: () => boolean;
+        getPendingFrameCount: () => number;
+        getPendingPromiseCount: () => number;
+        resetPendingState: () => void;
+        deactivateStealConsumer: (id: number) => boolean;
+        takeDeferredCount: () => number;
+        setPromiseHandler: (handler?: import("../memory/lock.js").PromisePayloadHandler) => void;
+    }[];
+    sharedQueue: {
+        rejectAll: (reason: string) => void;
+        hasPendingFrames: () => boolean;
+        txIdle: () => boolean;
+        completeFrame: () => number;
+        setReturnHooks: (lane: number, hooks: (import("../connections/buffer-reference.js").BufferReferenceReturnHooks | ((token: bigint) => void)) | undefined) => void;
+        enqueue: (functionID: number, timeout?: import("../types.js").TaskTimeout, abortSignal?: import("../types.js").AbortSignalOption) => (rawArgs: unknown) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
+        flushToWorker: () => boolean;
+        enqueueKnown: (task: Task) => boolean;
+        settlePromisePayload: (task: Task, isRejected: boolean, value: unknown) => boolean;
+    };
+    regionLanes: number;
+    abortSignalSAB: SharedArrayBuffer;
+    abortSignalMax: number;
+};
+export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, stealPool, }: {
     list: string[];
     ids: number[];
     names: string[];
@@ -30,6 +122,25 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
      * macro channel that runs all lane checks.
      */
     sharedChannelHandler?: ChannelHandler;
+    /**
+     * Work-stealing wiring. When present the submit region, both host-side locks
+     * and the pending registry are owned by `createPool` and shared: every worker
+     * claims from one request region, and the host demultiplexes responses by
+     * task id. This lane only contributes its private return region and its
+     * worker. The dispatcher is owned by the pool too, so none is built here.
+     */
+    stealPool?: {
+        submitBuffers: LockBuffers;
+        returnBuffers: LockBuffers;
+        hostSubmitLock: ReturnType<typeof lock2>;
+        hostReturnLock: ReturnType<typeof lock2>;
+        sharedQueue: ReturnType<typeof createHostTxQueue>;
+        consumers: number;
+        consumerId: number;
+        regionLanes: number;
+        abortSignalSAB?: LockBuffers["headers"];
+        abortSignalMax?: number;
+    };
 }) => (WorkerContext & {
     dispatcherCheck?: never;
     laneWake?: never;

package/src/runtime/pool.js

@@ -1,5 +1,6 @@
 import { createHostTxQueue } from "./tx-queue.js";
-import { cleanupProcessWorkerMemoryQuietly, createProcessSharedMemoryAllocator, createProcessWorkerMemoryLayout, createProcessWorkerNativeSignalNotifier, readProcessSharedMemorySettings, readProcessWorkerCommandPrefix, readProcessWorkerRuntime, serializeWorkerBootstrapData, spawnProcessWorker, terminateWorkerQuietly, toProcessWorkerBootPayload, toWorkerCompatExecArgv, toWorkerSafeExecArgv, } from "./process-worker.js";
+import { cleanupProcessWorkerMemoryQuietly, createProcessSharedMemoryAllocator, createProcessWorkerMemoryLayout, createProcessWorkerNativeSignalNotifier, readProcessSharedMemorySettings, readProcessWorkerCommandPrefix, readProcessWorkerRuntime, spawnProcessWorker, toProcessWorkerBootPayload, } from "./process-worker.js";
+import { serializeWorkerBootstrapData, terminateWorkerQuietly, toWorkerCompatExecArgv, toWorkerSafeExecArgv, } from "./worker-common.js";
 import { createSharedMemoryTransport, TRANSPORT_SIGNAL_BYTES, } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, hostDispatcherLoop, } from "./dispatcher.js";
 import { HEADER_SLOT_STRIDE_U32, lock2, LOCK_SECTOR_BYTE_LENGTH, LockBound, } from "../memory/lock.js";
@@ -7,7 +8,7 @@ import { HEADER_SLOT_STRIDE_U32, lock2, LOCK_SECTOR_BYTE_LENGTH, LockBound, } fr
 // see lock.ts). Must run before any lock2() call.
 import "../memory/payloadCodec.js";
 import "../worker/loop.js";
-import { createSharedArrayBuffer, createWasmSharedArrayBuffer, } from "../common/runtime.js";
+import { createSharedArrayBuffer, createWasmSharedArrayBuffer, IS_BROWSER, } from "../common/runtime.js";
 import { HAS_NODE_WORKER_THREADS, RUNTIME_WORKER, } from "../common/worker-runtime.js";
 import { probeLockBufferTextCompat } from "../common/shared-buffer-text.js";
 import { signalAbortFactory } from "../shared/abortSignal.js";
@@ -21,6 +22,15 @@ const isWorkerFatalMessage = (value) => !!value &&
     typeof value[WORKER_FATAL_MESSAGE_KEY] === "string";
 // Keep idle workers self-healing if an Atomics.notify wake is missed.
 const DEFAULT_WORKER_PARK_MS = 1;
+const DEFAULT_ABORT_SIGNAL_CAPACITY = 258;
+const sanitizePositiveInteger = (value) => {
+    if (!Number.isFinite(value))
+        return undefined;
+    const parsed = Math.floor(value);
+    return parsed > 0 ? parsed : undefined;
+};
+const resolveAbortSignalCapacity = (value) => sanitizePositiveInteger(value) ?? DEFAULT_ABORT_SIGNAL_CAPACITY;
+const abortSignalByteLength = (capacity) => Math.max(1, Math.ceil(capacity / 32)) * Uint32Array.BYTES_PER_ELEMENT;
 const withDefaultWorkerTimers = (options) => {
     const parkMs = options?.timers?.parkMs ?? DEFAULT_WORKER_PARK_MS;
     if (options === undefined)
@@ -38,7 +48,111 @@ const withFixedPayloadConfig = (config) => ({
     mode: "fixed",
     payloadInitialBytes: config.payloadMaxByteLength,
 });
-export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, }) => {
+/**
+ * Build the buffers, host-side locks and pending registry that a stealing pool
+ * shares. One submit region for every worker to claim from, one private return
+ * region per worker, and a single pool-global queue so a response arriving on
+ * any lane settles the right promise.
+ *
+ * Region width follows paper §6.1: the largest power-of-two `g` leaving a spare
+ * region for a delayed claimant (`slots / g >= consumers + 1`). At 32 slots that
+ * caps how wide a region can be well before it caps the worker count.
+ */
+export const resolveStealRegionLanes = (consumers) => {
+    for (let lanes = LockBound.slots; lanes >= 1; lanes >>= 1) {
+        if (LockBound.slots / lanes >= consumers + 1)
+            return lanes;
+    }
+    throw new RangeError(`${consumers} stealing workers need more than ${LockBound.slots} lanes`);
+};
+/** Maximum claimants that leave the protocol's required spare region. */
+export const MAX_STEAL_CONSUMERS = LockBound.slots - 1;
+export const createStealPoolBuffers = ({ threads, payload, regionLanes, abortSignalCapacity, usesAbortSignal, }) => {
+    const payloadConfig = resolvePayloadBufferOptions({ options: payload });
+    const makePayload = () => payloadConfig.mode === "growable"
+        ? createSharedArrayBuffer(payloadConfig.payloadInitialBytes, payloadConfig.payloadMaxByteLength)
+        : createSharedArrayBuffer(payloadConfig.payloadInitialBytes);
+    const carpet = () => createLockControlCarpet({
+        signalBytes: 0,
+        abortBytes: 0,
+        lockSectorBytes: LOCK_SECTOR_BYTE_LENGTH,
+        headerSlotStrideU32: HEADER_SLOT_STRIDE_U32,
+        slotCount: LockBound.slots,
+        headerLayout: "split",
+    });
+    const toBuffers = (half, payloadSab) => ({
+        ...half,
+        payload: payloadSab,
+        textCompat: probeLockBufferTextCompat({
+            headers: half.headers,
+            payload: payloadSab,
+        }),
+    });
+    const maxLanes = resolveStealRegionLanes(threads);
+    const lanes = regionLanes === undefined
+        ? maxLanes
+        : Math.min(Math.max(1, regionLanes | 0), maxLanes);
+    const submitCarpet = carpet();
+    const submitBuffers = toBuffers(submitCarpet.lock, makePayload());
+    const hostSubmitLock = lock2({
+        headers: submitBuffers.headers,
+        headerSlotStrideU32: submitBuffers.headerSlotStrideU32,
+        LockBoundSector: submitBuffers.lockSector,
+        payload: submitBuffers.payload,
+        payloadSector: submitBuffers.payloadSector,
+        payloadConfig,
+        textCompat: submitBuffers.textCompat,
+        consumers: threads,
+        regionLanes: lanes,
+    });
+    const returnBuffers = [];
+    const hostReturnLocks = [];
+    for (let i = 0; i < threads; i++) {
+        const buffers = toBuffers(carpet().returnLock, makePayload());
+        returnBuffers.push(buffers);
+        hostReturnLocks.push(lock2({
+            headers: buffers.headers,
+            headerSlotStrideU32: buffers.headerSlotStrideU32,
+            LockBoundSector: buffers.lockSector,
+            payload: buffers.payload,
+            payloadSector: buffers.payloadSector,
+            payloadConfig,
+            textCompat: buffers.textCompat,
+        }));
+    }
+    // Abort-aware tasks can execute on any claimant, so all workers and the
+    // pool-global queue must observe one bitmap. Per-lane abort buffers would
+    // encode an id from one allocator and test it against another lane's bits.
+    const resolvedAbortSignalCapacity = resolveAbortSignalCapacity(abortSignalCapacity);
+    const abortSignalSAB = usesAbortSignal === true
+        ? createSharedArrayBuffer(abortSignalByteLength(resolvedAbortSignalCapacity))
+        : undefined;
+    const abortSignals = abortSignalSAB === undefined
+        ? undefined
+        : signalAbortFactory({
+            sab: abortSignalSAB,
+            maxSignals: resolvedAbortSignalCapacity,
+        });
+    const sharedQueue = createHostTxQueue({
+        lock: hostSubmitLock,
+        returnLock: hostReturnLocks[0],
+        extraReturnLocks: hostReturnLocks.slice(1),
+        abortSignals,
+    });
+    return {
+        submitBuffers,
+        returnBuffers,
+        hostSubmitLock,
+        hostReturnLocks,
+        sharedQueue,
+        regionLanes: lanes,
+        abortSignalSAB,
+        abortSignalMax: abortSignalSAB === undefined
+            ? undefined
+            : resolvedAbortSignalCapacity,
+    };
+};
+export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, stealPool, }) => {
     if (workerOptions?.runtime === "compiled") {
         return spawnCompiledWorkerContext({
             list,
@@ -65,32 +179,32 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     if (!useProcessWorkerRuntime && typeof poliWorker !== "function") {
         throw new Error("Worker is not available in this runtime");
     }
+    // Without this the failure is a `ReferenceError` from whichever module
+    // happens to allocate first.
+    if (IS_BROWSER && typeof SharedArrayBuffer !== "function") {
+        throw new Error("SharedArrayBuffer is unavailable: serve the page cross-origin isolated " +
+            "(Cross-Origin-Opener-Policy: same-origin, " +
+            "Cross-Origin-Embedder-Policy: require-corp).");
+    }
     const WorkerCtor = poliWorker;
     // Lock buffers must be shared between host and worker.
-    const sanitizeBytes = (value) => {
-        if (!Number.isFinite(value))
-            return undefined;
-        const bytes = Math.floor(value);
-        return bytes > 0 ? bytes : undefined;
-    };
+    const sanitizeBytes = sanitizePositiveInteger;
     const basePayloadConfig = resolvePayloadBufferOptions({
         options: payload,
     });
     const resolvedPayloadConfig = useProcessWorkerRuntime
         ? withFixedPayloadConfig(basePayloadConfig)
         : basePayloadConfig;
-    const defaultAbortSignalCapacity = 258;
-    const requestedAbortSignalCapacity = sanitizeBytes(abortSignalCapacity);
-    const resolvedAbortSignalCapacity = requestedAbortSignalCapacity ??
-        defaultAbortSignalCapacity;
-    const abortSignalWords = Math.max(1, Math.ceil(resolvedAbortSignalCapacity / 32));
+    const resolvedAbortSignalCapacity = resolveAbortSignalCapacity(abortSignalCapacity);
     const requestedSignalBytes = sanitizeBytes(sab?.size);
     const externalSignalSab = sab?.sharedSab;
     if (useProcessWorkerRuntime && externalSignalSab != null) {
         throw new Error("process worker runtime cannot use an external signal buffer");
     }
     const signalBytes = Math.max(TRANSPORT_SIGNAL_BYTES, requestedSignalBytes ?? TRANSPORT_SIGNAL_BYTES);
-    const abortBytes = abortSignalWords * Uint32Array.BYTES_PER_ELEMENT;
+    const abortBytes = stealPool === undefined && usesAbortSignal === true
+        ? abortSignalByteLength(resolvedAbortSignalCapacity)
+        : 0;
     const processWorkerMemory = useProcessWorkerRuntime
         ? createProcessWorkerMemoryLayout({
             signalBytes,
@@ -132,7 +246,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     const controlLayout = processWorkerMemory?.controlLayout ??
         makeLockControlLayout();
     const lockPayload = processWorkerMemory?.lockPayload ?? makePayloadBuffer();
-    const lockBuffers = {
+    const lockBuffers = stealPool?.submitBuffers ?? {
         ...controlLayout.lock,
         payload: lockPayload,
         textCompat: probeLockBufferTextCompat({
@@ -142,7 +256,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     };
     const returnPayload = processWorkerMemory?.returnPayload ??
         makePayloadBuffer();
-    const returnLockBuffers = {
+    const returnLockBuffers = stealPool?.returnBuffers ?? {
         ...controlLayout.returnLock,
         payload: returnPayload,
         textCompat: probeLockBufferTextCompat({
@@ -150,7 +264,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
             payload: returnPayload,
         }),
     };
-    const lock = lock2({
+    const lock = stealPool?.hostSubmitLock ?? lock2({
         headers: lockBuffers.headers,
         headerSlotStrideU32: lockBuffers.headerSlotStrideU32,
         LockBoundSector: lockBuffers.lockSector,
@@ -160,7 +274,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         textCompat: lockBuffers.textCompat,
         processBoundary: useProcessWorkerRuntime,
     });
-    const returnLock = lock2({
+    const returnLock = stealPool?.hostReturnLock ?? lock2({
         headers: returnLockBuffers.headers,
         headerSlotStrideU32: returnLockBuffers.headerSlotStrideU32,
         LockBoundSector: returnLockBuffers.lockSector,
@@ -170,10 +284,9 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         textCompat: returnLockBuffers.textCompat,
         processBoundary: useProcessWorkerRuntime,
     });
-    const abortSignalSAB = usesAbortSignal === true
-        ? controlLayout.abortSignals
-        : undefined;
-    const abortSignals = abortSignalSAB
+    const abortSignalSAB = stealPool?.abortSignalSAB ??
+        (usesAbortSignal === true ? controlLayout.abortSignals : undefined);
+    const abortSignals = abortSignalSAB && stealPool === undefined
         ? signalAbortFactory({
             sab: abortSignalSAB,
             maxSignals: resolvedAbortSignalCapacity,
@@ -224,34 +337,38 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         }
         outstandingBorrowedReturns.clear();
     };
-    const queue = createHostTxQueue({
+    const returnHooks = bufferReferenceReturn === "borrow"
+        ? {
+            release: releaseBorrowedReturnToken,
+            track: (ref, token, aliasBuffer) => {
+                if (outstandingBorrowedReturns === undefined)
+                    return;
+                const record = outstandingBorrowedReturns.get(token);
+                if (record !== undefined) {
+                    if (aliasBuffer !== undefined) {
+                        record.aliasBuffer = new WeakRef(aliasBuffer);
+                    }
+                    return;
+                }
+                outstandingBorrowedReturns.set(token, {
+                    ref: new WeakRef(ref),
+                    aliasBuffer: aliasBuffer === undefined
+                        ? undefined
+                        : new WeakRef(aliasBuffer),
+                    runtime: ref.runtime,
+                });
+            },
+        }
+        : undefined;
+    const queue = stealPool?.sharedQueue ?? createHostTxQueue({
         lock,
         returnLock,
         abortSignals,
-        releaseBufferReferenceReturn: bufferReferenceReturn === "borrow"
-            ? {
-                release: releaseBorrowedReturnToken,
-                track: (ref, token, aliasBuffer) => {
-                    if (outstandingBorrowedReturns === undefined)
-                        return;
-                    const record = outstandingBorrowedReturns.get(token);
-                    if (record !== undefined) {
-                        if (aliasBuffer !== undefined) {
-                            record.aliasBuffer = new WeakRef(aliasBuffer);
-                        }
-                        return;
-                    }
-                    outstandingBorrowedReturns.set(token, {
-                        ref: new WeakRef(ref),
-                        aliasBuffer: aliasBuffer === undefined
-                            ? undefined
-                            : new WeakRef(aliasBuffer),
-                        runtime: ref.runtime,
-                    });
-                },
-            }
-            : undefined,
+        releaseBufferReferenceReturn: returnHooks,
     });
+    if (stealPool !== undefined) {
+        stealPool.sharedQueue.setReturnHooks(stealPool.consumerId, returnHooks);
+    }
     const { enqueue, rejectAll, txIdle, } = queue;
     const thisSignal = signalBox.opView;
     const a_add = Atomics.add;
@@ -271,16 +388,21 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     let dispatchSend = () => { };
     const send = () => dispatchSend();
     let channelHandler;
-    const ownsChannel = sharedChannelHandler === undefined;
+    const ownsChannel = sharedChannelHandler === undefined &&
+        stealPool === undefined;
     const ownChannel = sharedChannelHandler ?? new ChannelHandler();
-    const { check: dispatcherCheck } = hostDispatcherLoop({
-        signalBox,
-        queue,
-        channelHandler: ownChannel,
-        dispatcherOptions: host,
-        notifySignal: nativeNotifySignal,
-    });
-    if (ownsChannel) {
+    // Under stealing there is one queue, so one dispatcher drives it from the
+    // pool; a per-lane dispatcher would double-drain the shared registry.
+    const { check: dispatcherCheck } = stealPool !== undefined
+        ? { check: undefined }
+        : hostDispatcherLoop({
+            signalBox,
+            queue,
+            channelHandler: ownChannel,
+            dispatcherOptions: host,
+            notifySignal: nativeNotifySignal,
+        });
+    if (ownsChannel && dispatcherCheck !== undefined) {
         ownChannel.open(dispatcherCheck);
         channelHandler = ownChannel;
         dispatchSend = () => {
@@ -304,9 +426,8 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     const workerDataPayload = {
         sab: signals.sab,
         abortSignalSAB,
-        abortSignalMax: usesAbortSignal === true
-            ? resolvedAbortSignalCapacity
-            : undefined,
+        abortSignalMax: stealPool?.abortSignalMax ??
+            (usesAbortSignal === true ? resolvedAbortSignalCapacity : undefined),
         list,
         ids,
         names,
@@ -321,6 +442,11 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         payloadConfig: resolvedPayloadConfig,
         bufferReferenceReturn,
         permission,
+        steal: stealPool === undefined ? undefined : {
+            consumers: stealPool.consumers,
+            consumerId: stealPool.consumerId,
+            regionLanes: stealPool.regionLanes,
+        },
     };
     const baseWorkerOptions = {
         //@ts-ignore Reason
@@ -389,6 +515,20 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         worker.postMessage?.(workerDataPayload);
     }
     let closedReason;
+    const deactivateStealConsumer = () => {
+        stealPool?.hostSubmitLock.deactivateStealConsumer(stealPool.consumerId);
+    };
+    const terminateFailedWorker = () => {
+        try {
+            worker.unref?.();
+            void Promise.resolve(worker.terminate())
+                .catch(() => { })
+                .finally(deactivateStealConsumer);
+        }
+        catch {
+            deactivateStealConsumer();
+        }
+    };
     // `workerBytesReadable`: while the worker is still alive its pinned bytes
     // can be copied out; after a crash/exit they are gone and borrows are
     // detached so stale reads fail loud instead of aliasing freed memory.
@@ -404,18 +544,22 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         if (!isWorkerFatalMessage(message))
             return;
         markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`, true);
-        terminateWorkerQuietly(worker);
+        terminateFailedWorker();
     };
     const onWorkerError = (error) => {
         const message = String(error?.message ?? error);
         markWorkerClosed(`Worker crashed: ${message}`);
+        terminateFailedWorker();
     };
     const nodeWorker = worker;
     if (typeof nodeWorker.on === "function") {
         nodeWorker.on("message", onWorkerMessage);
         nodeWorker.on("error", onWorkerError);
         nodeWorker.on("exit", (code) => {
-            if (typeof code === "number" && code === 0)
+            // Exit is the point at which this endpoint can no longer write WANT, so
+            // survivors may safely ignore any intent it left behind.
+            deactivateStealConsumer();
+            if (closedReason !== undefined)
                 return;
             const normalized = typeof code === "number" ? code : -1;
             markWorkerClosed(`Worker exited with code ${normalized}`);
@@ -463,8 +607,10 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         lock,
         processSharedMemoryBackings: processSharedMemory?.backings,
         dispatcherCheck,
-        laneWake: sharedChannelHandler !== undefined ? laneWake : undefined,
-        bindSend: sharedChannelHandler !== undefined
+        laneWake: sharedChannelHandler !== undefined || stealPool !== undefined
+            ? laneWake
+            : undefined,
+        bindSend: sharedChannelHandler !== undefined || stealPool !== undefined
             ? ((fn) => void (dispatchSend = fn))
             : undefined,
     };