knitting 0.1.60 → 0.1.61

package/src/api.js

@@ -3,13 +3,13 @@ import { DEBUG_ENABLED, resolveDebugNamespaces } from "./debug/gate.js";
 import { genTaskID } from "./common/task-source.js";
 import { toModuleUrl } from "./common/module-url.js";
 import { endpointSymbol } from "./common/task-symbol.js";
-import { spawnWorkerContext } from "./runtime/pool.js";
-import { ChannelHandler } from "./runtime/dispatcher.js";
-import { RUNTIME } from "./common/runtime.js";
+import { createStealPoolBuffers, MAX_STEAL_CONSUMERS, spawnWorkerContext, } from "./runtime/pool.js";
+import { ChannelHandler, hostDispatcherLoop } from "./runtime/dispatcher.js";
+import { createSharedArrayBuffer, RUNTIME } from "./common/runtime.js";
 import { RUNTIME_IS_MAIN_THREAD, RUNTIME_POOL_DEPTH, RUNTIME_WORKER_DATA, } from "./common/worker-runtime.js";
 import { classifyProcessPermissionCompatibility, enforceProcessPermissionCompatibility, resolvePermissionProtocol, toRuntimePermissionFlags, } from "./permission/index.js";
 import { getNodeProcess } from "./common/node-compat.js";
-import { readProcessWorkerCommandPrefix, readProcessWorkerRuntime, } from "./runtime/process-worker.js";
+import { readProcessWorkerNodeMajor, readProcessWorkerRuntime, } from "./runtime/process-worker.js";
 import { inspectCompiledWorkerArtifact } from "./runtime/compiled-artifact.js";
 import { managerMethod } from "./runtime/balancer.js";
 import { createInlineExecutor } from "./runtime/inline-executor.js";
@@ -46,18 +46,6 @@ const readHostCwd = () => {
     }
     return undefined;
 };
-const readKnownProcessWorkerNodeMajor = (worker) => {
-    if (RUNTIME !== "node")
-        return undefined;
-    if (readProcessWorkerCommandPrefix(worker) !== undefined)
-        return undefined;
-    const nodeProcess = getNodeProcess();
-    if (nodeProcess?.env?.NODE_BINARY !== undefined)
-        return undefined;
-    const raw = nodeProcess?.versions?.node;
-    const major = Number.parseInt(String(raw).split(".", 1)[0] ?? "", 10);
-    return Number.isInteger(major) && major > 0 ? major : undefined;
-};
 const formatDebugList = (values, empty = "(none)") => values && values.length > 0 ? values.join(",") : empty;
 const MAX_FUNCTION_ID = 0xFFFF;
 const MAX_FUNCTION_COUNT = MAX_FUNCTION_ID + 1;
@@ -375,6 +363,24 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     hostDebug?.log(`permission=${permissionProtocol?.mode ?? "off"} execArgv=${formatDebugList(execArgv)}`);
     const usesAbortSignal = listOfFunctions.some((fn) => fn.abortSignal !== undefined);
     const resolvedWorker = resolveWorkerSettings(worker, callerHref);
+    const dispatcherEnv = nodeProcess?.env?.KNITTING_DISPATCHER;
+    const stealEnvRaw = nodeProcess?.env?.KNITTING_STEAL?.trim().toLowerCase();
+    const stealEnv = stealEnvRaw === "1" || stealEnvRaw === "true"
+        ? true
+        : stealEnvRaw === "0" || stealEnvRaw === "false"
+            ? false
+            : undefined;
+    // Shared-submit stealing is the default for compatible multi-worker thread
+    // pools. An explicit option wins over the environment; process/compiled/
+    // inline transports retain their existing topology unless the caller
+    // explicitly requests an unsupported combination.
+    const dispatcherExplicitlySelected = host?.dispatcher !== undefined ||
+        dispatcherEnv === "serial-channel" || dispatcherEnv === "per-thread";
+    const stealDefaultCompatible = balancer === undefined &&
+        !dispatcherExplicitlySelected && (threads ?? 1) <= MAX_STEAL_CONSUMERS;
+    const stealRequested = host?.steal ?? stealEnv ?? stealDefaultCompatible;
+    const stealExplicitlyEnabled = host?.steal === true ||
+        (host?.steal === undefined && stealEnv === true);
     const usingCompiledWorker = resolvedWorker?.runtime === "compiled";
     if (resolvedWorker?.compiled !== undefined && !usingCompiledWorker) {
         throw new Error("worker.compiled requires worker.runtime to be compiled");
@@ -429,6 +435,9 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     if (usingInliner && resolvedWorker?.bootstrap !== undefined) {
         throw new Error("worker.bootstrap cannot be used with the inliner");
     }
+    if (stealExplicitlyEnabled && resolvedWorker?.runtime === "process") {
+        throw new Error("host.steal does not support process workers; use worker threads or disable stealing");
+    }
     if (resolvedWorker?.runtime === "process") {
         const processRuntime = readProcessWorkerRuntime(resolvedWorker);
         enforceProcessPermissionCompatibility(classifyProcessPermissionCompatibility({
@@ -437,7 +446,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             target: {
                 runtime: processRuntime,
                 nodeMajor: processRuntime === "node"
-                    ? readKnownProcessWorkerNodeMajor(resolvedWorker)
+                    ? readProcessWorkerNodeMajor(resolvedWorker)
                     : undefined,
             },
         }));
@@ -454,7 +463,6 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             `(import { isMain } from "knitting") so only the main program starts ` +
             `the pool.`);
     }
-    const dispatcherEnv = nodeProcess?.env?.KNITTING_DISPATCHER;
     const explicitDispatcher = host?.dispatcher ??
         (dispatcherEnv === "serial-channel" || dispatcherEnv === "per-thread"
             ? dispatcherEnv
@@ -470,7 +478,25 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         return "serial-channel";
     })();
     const dispatcher = explicitDispatcher ?? autoDispatcher;
-    const serialChannel = !usingCompiledWorker &&
+    // Work stealing: one shared submit region, private return lanes, one
+    // pool-global pending registry. It is the compatible multi-thread default;
+    // an explicit balancer/dispatcher keeps the private-lane topology unless
+    // stealing itself was explicitly requested.
+    const useSteal = stealRequested &&
+        !usingCompiledWorker &&
+        resolvedWorker?.runtime !== "process" &&
+        (threads ?? 1) > 1 &&
+        !usingInliner;
+    const stealBuffers = useSteal
+        ? createStealPoolBuffers({
+            threads: threads ?? 1,
+            payload,
+            regionLanes: host?.stealRegionLanes,
+            abortSignalCapacity,
+            usesAbortSignal,
+        })
+        : undefined;
+    const serialChannel = !usingCompiledWorker && !useSteal &&
         dispatcher === "serial-channel";
     const serialDispatcherChannel = serialChannel
         ? new ChannelHandler()
@@ -496,14 +522,83 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         usesAbortSignal,
         permission: permissionProtocol,
         sharedChannelHandler: serialDispatcherChannel,
+        stealPool: stealBuffers === undefined ? undefined : {
+            submitBuffers: stealBuffers.submitBuffers,
+            returnBuffers: stealBuffers.returnBuffers[thread],
+            hostSubmitLock: stealBuffers.hostSubmitLock,
+            hostReturnLock: stealBuffers.hostReturnLocks[thread],
+            sharedQueue: stealBuffers.sharedQueue,
+            consumers: threads ?? 1,
+            consumerId: thread,
+            regionLanes: stealBuffers.regionLanes,
+            abortSignalSAB: stealBuffers.abortSignalSAB,
+            abortSignalMax: stealBuffers.abortSignalMax,
+        },
     }));
+    const stealChannel = useSteal ? new ChannelHandler() : undefined;
+    if (useSteal) {
+        const channel = stealChannel;
+        const queue = stealBuffers.sharedQueue;
+        // Wake exactly one worker per drain, round-robin. Stealing decouples the
+        // wake target from the assignment: if the woken worker is busy, any other
+        // idle endpoint claims the region instead. So this costs one notify per
+        // publish regardless of pool size, rather than one per lane.
+        let wakeCursor = 0;
+        const wakeOne = () => {
+            const lanes = workers.length;
+            if (lanes === 0)
+                return;
+            const lane = wakeCursor;
+            wakeCursor = wakeCursor + 1 < lanes ? wakeCursor + 1 : 0;
+            workers[lane].laneWake?.();
+        };
+        // The shared dispatcher drives one queue, so it needs signal words of its
+        // own rather than any single lane's; waking is delegated to `wakeOne`.
+        const signalWords = new Int32Array(createSharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT));
+        const { check } = hostDispatcherLoop({
+            signalBox: {
+                opView: signalWords.subarray(0, 1),
+                txStatus: signalWords.subarray(1, 2),
+                rxStatus: signalWords.subarray(2, 3),
+            },
+            queue,
+            channelHandler: channel,
+            dispatcherOptions: host,
+            notifySignal: wakeOne,
+        });
+        channel.open(check);
+        workers.forEach((context) => {
+            context.bindSend(() => {
+                if (check.isRunning !== true) {
+                    check.isRunning = true;
+                    Promise.resolve().then(check);
+                }
+                wakeOne();
+            });
+        });
+        hostDebug?.log(`dispatcher=steal lanes=${workers.length} g=${stealBuffers.regionLanes}`);
+    }
     const sharedDispatcherChannel = serialDispatcherChannel;
     if (serialChannel) {
         const channel = serialDispatcherChannel;
         const checks = workers.map((context) => context.dispatcherCheck);
+        const laneIdle = workers.map((context) => context.txIdle);
         let serialScheduled = false;
         let serialInFlight = false;
         let serialRerun = false;
+        // Busy-lane set: a tick walks only the lanes that have work, not all of
+        // them. `active` is a dense list of lane indices; `isActive` keeps the
+        // membership test O(1). A lane joins on send() and leaves once its queue
+        // reports idle, so an N-worker pool with one busy lane costs one check per
+        // tick instead of N.
+        const active = [];
+        const isActive = new Uint8Array(checks.length);
+        const markActive = (lane) => {
+            if (isActive[lane] === 1)
+                return;
+            isActive[lane] = 1;
+            active.push(lane);
+        };
         const runSerialChecks = () => {
             if (serialInFlight) {
                 serialRerun = true;
@@ -513,11 +608,19 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             do {
                 serialRerun = false;
                 serialScheduled = false;
-                for (let index = 0; index < checks.length; index++) {
-                    const check = checks[index];
+                // Walk backwards so dropping an idle lane is a swap-with-last pop.
+                for (let index = active.length - 1; index >= 0; index--) {
+                    const lane = active[index];
+                    const check = checks[lane];
                     if (check.isRunning !== true)
                         check.isRunning = true;
                     check();
+                    if (laneIdle[lane]()) {
+                        isActive[lane] = 0;
+                        const last = active.pop();
+                        if (index < active.length)
+                            active[index] = last;
+                    }
                 }
             } while (serialRerun);
             serialInFlight = false;
@@ -533,9 +636,10 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             Promise.resolve().then(runSerialChecks);
         };
         channel.open(runSerialChecks);
-        workers.forEach((context) => {
+        workers.forEach((context, lane) => {
             const wake = context.laneWake;
             context.bindSend(() => {
+                markActive(lane);
                 scheduleSerialCheck();
                 wake();
             });
@@ -580,6 +684,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         closePromise = Promise.allSettled(workers.map((context) => context.kills()))
             .then(() => {
             sharedDispatcherChannel?.close();
+            stealChannel?.close();
         });
         return closePromise;
     };

package/src/common/runtime.d.ts

@@ -1,8 +1,9 @@
-type RuntimeName = "deno" | "bun" | "node" | "andromeda" | "unknown";
+type RuntimeName = "deno" | "bun" | "node" | "andromeda" | "browser" | "unknown";
 export declare const IS_DENO: boolean;
 export declare const IS_BUN: boolean;
 export declare const IS_NODE: boolean;
 export declare const IS_ANDROMEDA: boolean;
+export declare const IS_BROWSER: boolean;
 export declare const RUNTIME: RuntimeName;
 export declare const SET_IMMEDIATE: typeof setImmediate & ((cb: () => void) => void);
 export declare const HAS_SHARED_WASM_MEMORY: boolean;

package/src/common/runtime.js

@@ -7,6 +7,11 @@ export const IS_NODE = typeof nodeProcess?.versions?.node === "string";
 // Andromeda (Nova engine): no `node:` builtins or `WebAssembly`; detect via
 // its private bootstrap global.
 export const IS_ANDROMEDA = typeof globals.__andromeda__ !== "undefined";
+// A page or a web worker: no `node:` builtins, but `Worker`, `MessageChannel`,
+// and a cross-origin isolated `SharedArrayBuffer` are all the pool needs.
+export const IS_BROWSER = !IS_DENO && !IS_BUN && !IS_NODE && !IS_ANDROMEDA &&
+    (typeof globals.document !== "undefined" ||
+        typeof globals.WorkerGlobalScope === "function");
 export const RUNTIME = (IS_DENO
     ? "deno"
     : IS_BUN
@@ -15,7 +20,9 @@ export const RUNTIME = (IS_DENO
             ? "node"
             : IS_ANDROMEDA
                 ? "andromeda"
-                : "unknown");
+                : IS_BROWSER
+                    ? "browser"
+                    : "unknown");
 // `WebAssembly` may be undeclared (not just undefined) on Andromeda, where a
 // bare reference throws; capture it through `globalThis` so access is safe.
 const WebAssemblyRef = globals.WebAssembly;

package/src/memory/lock.d.ts

@@ -159,6 +159,20 @@ export declare const HEADER_SLOT_STRIDE_BYTES: number;
 export declare const HEADER_TASK_LINE_U32: number;
 export declare const HEADER_STATIC_PAYLOAD_U32: number;
 export declare const HEADER_TASK_OFFSET_IN_SLOT_U32: number;
+export declare const STEAL_ACK_SLOT_OFFSET_U32: number;
+export declare const STEAL_WANT_SLOT_OFFSET_U32: number;
+/**
+ * The payload allocator needs its own participant-owned ACK per consumer, since
+ * several workers can free payload slots from one shared allocator. No intent
+ * word: freeing needs no arbitration, a consumer only frees what it drained.
+ */
+export declare const STEAL_PAYLOAD_ACK_SLOT_OFFSET_U32: number;
+/**
+ * Host-owned liveness mask for stealing consumers. A dead claimant may leave
+ * its WANT word set forever; survivors ignore WANT from consumers whose bit is
+ * clear here. This preserves single-writer ownership of every WANT word.
+ */
+export declare const STEAL_LIVE_SLOT_OFFSET_U32: number;
 export declare const HEADER_U32_LENGTH: number;
 export declare const HEADER_BYTE_LENGTH: number;
 export declare const makeTask: () => Task;
@@ -177,7 +191,7 @@ type ResolveHostOptions = {
  *  - encode/decode are not re-entrant; payload codec uses a shared scratch buffer.
  */
 export type Lock2 = ReturnType<typeof lock2>;
-export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, processBoundary, }: {
+export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, processBoundary, consumers, consumerId, regionLanes, }: {
     headers?: SharedBufferSource;
     headerSlotStrideU32?: number;
     LockBoundSector?: SharedBufferSource;
@@ -189,6 +203,16 @@ export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, pa
     resultList?: RingQueue<Task>;
     recycleList?: RingQueue<Task>;
     processBoundary?: boolean;
+    /**
+     * Number of consumer endpoints sharing this lock. `1` (default) keeps the
+     * classic single-consumer path. `> 1` enables region-Dekker work stealing and
+     * is only valid on a host->worker submit lock, never on a return lock.
+     */
+    consumers?: number;
+    /** This endpoint's id, `0..consumers-1`. Priority is fixed by id. */
+    consumerId?: number;
+    /** Lanes claimed per Dekker handshake. Paper rule: `slots / regionLanes >= consumers + 1`. */
+    regionLanes?: number;
 }) => {
     enlist: (task: Task) => true;
     encode: (task: Task, state?: number) => boolean;
@@ -207,6 +231,7 @@ export declare const lock2: ({ headers, headerSlotStrideU32, LockBoundSector, pa
     getPendingFrameCount: () => number;
     getPendingPromiseCount: () => number;
     resetPendingState: () => void;
+    deactivateStealConsumer: (id: number) => boolean;
     takeDeferredCount: () => number;
     setPromiseHandler: (handler?: PromisePayloadHandler) => void;
 };

package/src/memory/lock.js

@@ -226,6 +226,27 @@ export const HEADER_TASK_LINE_U32 = LOCK_CACHE_LINE_BYTES /
 export const HEADER_STATIC_PAYLOAD_U32 = TaskIndex.TotalBuff -
     HEADER_TASK_LINE_U32;
 export const HEADER_TASK_OFFSET_IN_SLOT_U32 = HEADER_STATIC_PAYLOAD_U32;
+// Work-stealing control words live in the unused tail of each slot's header
+// cache line. Task words occupy 0..7 (`TASK_LOCAL_FLAGS_INDEX = 7`) of the
+// 16-word line, leaving words 8..15 free. Consumer `c` owns slot `c`'s pair, and
+// because the slot stride is exactly 9 cache lines those pairs land on distinct
+// lines. `ACK[c]` and `WANT[c]` share one line on purpose: same single writer,
+// and a peer reading one pulls the other for free.
+export const STEAL_ACK_SLOT_OFFSET_U32 = HEADER_TASK_OFFSET_IN_SLOT_U32 +
+    TaskIndex.Size;
+export const STEAL_WANT_SLOT_OFFSET_U32 = STEAL_ACK_SLOT_OFFSET_U32 + 1;
+/**
+ * The payload allocator needs its own participant-owned ACK per consumer, since
+ * several workers can free payload slots from one shared allocator. No intent
+ * word: freeing needs no arbitration, a consumer only frees what it drained.
+ */
+export const STEAL_PAYLOAD_ACK_SLOT_OFFSET_U32 = STEAL_ACK_SLOT_OFFSET_U32 + 2;
+/**
+ * Host-owned liveness mask for stealing consumers. A dead claimant may leave
+ * its WANT word set forever; survivors ignore WANT from consumers whose bit is
+ * clear here. This preserves single-writer ownership of every WANT word.
+ */
+export const STEAL_LIVE_SLOT_OFFSET_U32 = STEAL_PAYLOAD_ACK_SLOT_OFFSET_U32 + 1;
 export const HEADER_U32_LENGTH = LockBound.header +
     (HEADER_SLOT_STRIDE_U32 * LockBound.slots);
 export const HEADER_BYTE_LENGTH = HEADER_U32_LENGTH *
@@ -276,7 +297,7 @@ const settleTask = (task) => {
         task[TaskIndex["FlagsToHost"]] = 0;
     }
 };
-export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, processBoundary, }) => {
+export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload, payloadConfig, payloadSector, textCompat, resultList, toSentList, recycleList, processBoundary, consumers, consumerId, regionLanes, }) => {
     // Layout within `lockSectorRegion`:
     // - hostBits starts at byte 0
     // - workerBits starts at byte 64
@@ -308,6 +329,55 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         headers: headersRegion,
         payload: payloadSAB,
     });
+    // ---- work stealing (multi-consumer) state ----
+    // With N consumers the pending set is A ^ ACK[0] ^ ... ^ ACK[N-1]; every word
+    // still has exactly one writer, so no shared writable word is introduced.
+    const stealConsumers = Math.max(1, (consumers ?? 1) | 0);
+    const stealEnabled = stealConsumers > 1;
+    // A lock2 built without `consumerId` is the producer endpoint: it encodes but
+    // never claims. It still frees payload slots, so it needs an acknowledgement
+    // word of its own rather than sharing consumer 0's.
+    const stealIsProducer = consumerId === undefined;
+    const stealId = (consumerId ?? 0) | 0;
+    const stealRegionLanes = (regionLanes ?? 8) | 0;
+    const stealRegions = (LockBound.slots / stealRegionLanes) | 0;
+    if (stealEnabled) {
+        if (stealRegionLanes < 1 || (stealRegionLanes & (stealRegionLanes - 1)) !== 0) {
+            throw new RangeError("regionLanes must be a power of two");
+        }
+        if (stealRegions < stealConsumers) {
+            throw new RangeError(`regionLanes=${stealRegionLanes} yields ${stealRegions} regions, ` +
+                `too few for ${stealConsumers} consumers`);
+        }
+        if (stealId < 0 || stealId >= stealConsumers) {
+            throw new RangeError(`consumerId ${stealId} out of range`);
+        }
+    }
+    // Int32 alias over the headers SAB so the control words get signed bit math
+    // consistent with the rest of the protocol.
+    const stealView = new Int32Array(headersRegion.sab, headersRegion.byteOffset, headersRegion.byteLength >>> 2);
+    const stealAckIndex = new Int32Array(stealConsumers);
+    const stealWantIndex = new Int32Array(stealConsumers);
+    for (let c = 0; c < stealConsumers; c++) {
+        const slotBase = (c * headersSlotStride) + LockBound.header;
+        stealAckIndex[c] = slotBase + STEAL_ACK_SLOT_OFFSET_U32;
+        stealWantIndex[c] = slotBase + STEAL_WANT_SLOT_OFFSET_U32;
+    }
+    const stealLiveIndex = LockBound.header + STEAL_LIVE_SLOT_OFFSET_U32;
+    const stealAllLiveMask = stealConsumers === 32
+        ? -1
+        : ((1 << stealConsumers) - 1) | 0;
+    if (stealEnabled && stealIsProducer) {
+        Atomics.store(stealView, stealLiveIndex, stealAllLiveMask);
+    }
+    const stealIsLive = (mask, consumer) => (mask & (1 << consumer)) !== 0;
+    const stealAckXorAll = () => {
+        let x = 0 | 0;
+        for (let c = 0; c < stealConsumers; c++) {
+            x = (x ^ a_load(stealView, stealAckIndex[c])) | 0;
+        }
+        return x;
+    };
     let promiseHandler;
     if (registeredEncodePayload === undefined ||
         registeredDecodePayload === undefined) {
@@ -362,8 +432,11 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
     // false-busy-only sender-side staleness property, this may hide newly freed
     // lanes but cannot make a genuinely pending lane appear free. Refresh only
     // when the cached free set is exhausted.
-    let workerShadow = a_load(workerBits, 0) | 0;
-    const refreshWorkerShadow = () => workerShadow = a_load(workerBits, 0) | 0;
+    let workerShadow = 0 | 0;
+    const refreshWorkerShadow = stealEnabled
+        ? () => workerShadow = stealAckXorAll()
+        : () => workerShadow = a_load(workerBits, 0) | 0;
+    refreshWorkerShadow();
     const ensureSenderStateHasFree = (state) => (~state) !== 0 ? state : (LastLocal ^ refreshWorkerShadow()) | 0;
     // RingQueue method aliases (hot path)
     const toBeSentPush = (task) => toBeSent.push(task);
@@ -561,6 +634,122 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         lastTake = last;
         return true;
     };
+    /**
+     * WORKER SIDE: decode, region-Dekker stealing variant.
+     *
+     * Claims one whole region of `stealRegionLanes` lanes per handshake, so the
+     * StoreLoad barrier is amortised over the region rather than paid per task.
+     * Priority is fixed by endpoint id: a junior withdraws for a senior, so at
+     * most one consumer ever acknowledges a published generation.
+     *
+     * The C reference needs an explicit mfence between the intent store and the
+     * peer loads. `Atomics.store` is sequentially consistent in JS, so that
+     * barrier is implicit here and holds on x86 and ARM alike.
+     */
+    const stealLaneMask = (region) => stealRegionLanes === 32
+        ? -1
+        : ((((1 << stealRegionLanes) - 1) << (region * stealRegionLanes)) | 0);
+    const stealPeerAcks = () => {
+        let x = 0 | 0;
+        for (let c = 0; c < stealConsumers; c++) {
+            if (c !== stealId)
+                x = (x ^ a_load(stealView, stealAckIndex[c])) | 0;
+        }
+        return x;
+    };
+    const stealJuniorWants = (intent) => {
+        const live = a_load(stealView, stealLiveIndex) | 0;
+        for (let c = stealId + 1; c < stealConsumers; c++) {
+            if (!stealIsLive(live, c))
+                continue;
+            if ((a_load(stealView, stealWantIndex[c]) & intent) !== 0)
+                return true;
+        }
+        return false;
+    };
+    let stealCursor = ((stealRegions * stealId) / stealConsumers) | 0;
+    const decodeSteal = () => {
+        const pending = (a_load(hostBits, 0) ^ LastWorker ^ stealPeerAcks()) | 0;
+        if (pending === 0)
+            return false;
+        let pendingRegions = 0 | 0;
+        if (stealRegions === 1)
+            pendingRegions = 1;
+        else {
+            for (let r = 0; r < stealRegions; r++) {
+                if ((pending & stealLaneMask(r)) !== 0)
+                    pendingRegions |= 1 << r;
+            }
+        }
+        const liveBeforeClaim = a_load(stealView, stealLiveIndex) | 0;
+        let peerIntent = 0 | 0;
+        let seniorIntent = 0 | 0;
+        for (let c = 0; c < stealConsumers; c++) {
+            if (c === stealId || !stealIsLive(liveBeforeClaim, c))
+                continue;
+            const value = a_load(stealView, stealWantIndex[c]) | 0;
+            peerIntent |= value;
+            if (c < stealId)
+                seniorIntent |= value;
+        }
+        const notSenior = pendingRegions & ~seniorIntent;
+        if (notSenior === 0)
+            return false;
+        const clean = pendingRegions & ~peerIntent;
+        const candidates = clean !== 0 ? clean : notSenior;
+        let region = -1;
+        for (let step = 0; step < stealRegions; step++) {
+            const candidate = (stealCursor + step) % stealRegions;
+            if ((candidates & (1 << candidate)) !== 0) {
+                region = candidate;
+                break;
+            }
+        }
+        if (region < 0)
+            return false;
+        const intent = (1 << region) | 0;
+        a_store(stealView, stealWantIndex[stealId], intent);
+        // Dekker StoreLoad: implicit, `Atomics.store` above is seq-cst.
+        let seniorConflict = false;
+        let juniorConflict = false;
+        for (let c = 0; c < stealConsumers; c++) {
+            if (c === stealId || !stealIsLive(liveBeforeClaim, c))
+                continue;
+            if ((a_load(stealView, stealWantIndex[c]) & intent) === 0)
+                continue;
+            if (c < stealId)
+                seniorConflict = true;
+            else
+                juniorConflict = true;
+        }
+        if (seniorConflict) {
+            a_store(stealView, stealWantIndex[stealId], 0);
+            return false;
+        }
+        if (juniorConflict) {
+            while (stealJuniorWants(intent)) { /* junior withdraws */ }
+        }
+        // Last control loads before ownership. After this no control word is read
+        // until every slot in `take` has been decoded.
+        const take = ((a_load(hostBits, 0) ^ LastWorker ^ stealPeerAcks()) &
+            stealLaneMask(region)) | 0;
+        if (take === 0) {
+            a_store(stealView, stealWantIndex[stealId], 0);
+            return false;
+        }
+        let lanes = take;
+        while (lanes !== 0) {
+            decodeAt(31 - clz32((lanes & -lanes) >>> 0));
+            lanes = (lanes & (lanes - 1)) | 0;
+        }
+        // Retire the whole claimed mask with one ACK store, then release the region.
+        // ACK before intent-clear (paper Assumption 2(ii)).
+        LastWorker = (LastWorker ^ take) | 0;
+        a_store(stealView, stealAckIndex[stealId], LastWorker);
+        a_store(stealView, stealWantIndex[stealId], 0);
+        stealCursor = (region + 1) % stealRegions;
+        return true;
+    };
     /**
      * HOST SIDE: decode version
      */
@@ -730,6 +919,24 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         deferredCount = 0 | 0;
         pendingPromiseCount = 0 | 0;
     };
+    /**
+     * HOST SIDE: remove a terminated consumer from stealing arbitration.
+     *
+     * Its ACK remains part of the generation XOR forever, because it records
+     * lanes that consumer retired while alive. Only its stale WANT becomes
+     * ineligible. The caller must invoke this only after the endpoint can no
+     * longer execute; there is deliberately no matching reactivation operation.
+     */
+    const deactivateStealConsumer = (id) => {
+        if (!stealEnabled || !stealIsProducer)
+            return false;
+        if (!Number.isInteger(id) || id < 0 || id >= stealConsumers) {
+            throw new RangeError(`consumerId ${id} out of range`);
+        }
+        const bit = 1 << id;
+        const previous = Atomics.and(stealView, stealLiveIndex, ~bit);
+        return (previous & bit) !== 0;
+    };
     return {
         enlist,
         encode,
@@ -737,7 +944,7 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         encodeAll,
         publish,
         flushPending,
-        decode,
+        decode: stealEnabled ? decodeSteal : decode,
         hasSpace,
         resolved,
         hostBits,
@@ -748,6 +955,7 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         getPendingFrameCount: () => toBeSent.size | 0,
         getPendingPromiseCount: () => pendingPromiseCount | 0,
         resetPendingState,
+        deactivateStealConsumer,
         takeDeferredCount: () => {
             const count = deferredCount | 0;
             deferredCount = 0 | 0;

package/src/memory/payloadCodec.js

@@ -311,9 +311,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         options: payload?.config ?? payloadConfig,
     });
     const maxPayloadBytes = resolvedPayloadConfig.maxPayloadBytes;
-    const { allocTask, setSlotLength, free } = register({
-        lockSector,
-    });
+    const { allocTask, setSlotLength, free } = register({ lockSector });
     const { writeBinary: writeDynamicBinary, writeBuffer: writeDynamicBuffer, writeArrayBuffer: writeDynamicArrayBuffer, write8Binary: writeDynamic8Binary, writeUtf8: writeDynamicUtf8, } = createSharedDynamicBufferIO({
         sab: payloadSab,
         payloadConfig: resolvedPayloadConfig,
@@ -1219,9 +1217,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         sab: payloadSab,
         options: payload?.config ?? payloadConfig,
     });
-    const { free } = register({
-        lockSector,
-    });
+    const { free } = register({ lockSector });
     const freeTaskSlot = (task) => free(getTaskSlotIndex(task));
     const { readUtf8: readDynamicUtf8, readBytesCopy: readDynamicBytesCopy, readBytesBufferCopy: readDynamicBufferCopy, readBufferCopy: readDynamicBuffer, readBytesArrayBufferCopy: readDynamicArrayBufferCopy, readArrayBufferCopy: readDynamicArrayBuffer, read8BytesFloatCopy: readDynamic8BytesFloatCopy, read8BytesFloatView: readDynamic8BytesFloatView, } = createSharedDynamicBufferIO({
         sab: payloadSab,

package/src/memory/regionRegistry.d.ts

@@ -1,10 +1,8 @@
 import type { Task } from "./lock.js";
 import { type SharedBufferSource } from "../common/shared-buffer-region.js";
 export type RegisterMalloc = ReturnType<typeof register>;
-export type RegionRegistryPublishMode = "plain" | "atomic";
-export declare const register: ({ lockSector, publishMode, }: {
+export declare const register: ({ lockSector, }: {
     lockSector?: SharedBufferSource;
-    publishMode?: RegionRegistryPublishMode;
 }) => {
     allocTask: (task: Task) => number;
     setSlotLength: (slotIndex: number, payloadLen: number) => boolean;