knitting 0.1.60 → 0.1.62

package/src/memory/lock.js

@@ -226,6 +226,29 @@ 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;
+/** Host-owned arm word for the return-lock completion doorbell. */
+export const DOORBELL_ARMED_SLOT_OFFSET_U32 = STEAL_LIVE_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 +299,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, notifyOnHostPublish, }) => {
     // Layout within `lockSectorRegion`:
     // - hostBits starts at byte 0
     // - workerBits starts at byte 64
@@ -295,6 +318,11 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
     const headersRegion = toSharedBufferRegion(headers ?? createWasmSharedArrayBuffer(HEADER_BYTE_LENGTH));
     const headersBuffer = new Uint32Array(headersRegion.sab, headersRegion.byteOffset, headersRegion.byteLength >>> 2);
     const headersSlotStride = headerSlotStrideU32 ?? HEADER_SLOT_STRIDE_U32;
+    // The first task cache line has four unused control words after the task
+    // header. Keep the doorbell arm bit in one of those words so the host and
+    // worker lock instances can share it without allocating another SAB.
+    const doorbellArmed = new Int32Array(headersRegion.sab, headersRegion.byteOffset +
+        (DOORBELL_ARMED_SLOT_OFFSET_U32 * Uint32Array.BYTES_PER_ELEMENT), 1);
     const resolvedPayloadConfig = resolvePayloadBufferOptions({
         sab: payload,
         options: payloadConfig,
@@ -308,6 +336,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) {
@@ -358,12 +435,20 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
     // Atomics aliases (hot path)
     const a_load = Atomics.load;
     const a_store = Atomics.store;
+    const a_notify = Atomics.notify;
+    const shouldNotifyHostPublish = notifyOnHostPublish === true;
+    const a_waitAsync = typeof Atomics.waitAsync === "function"
+        ? Atomics.waitAsync.bind(Atomics)
+        : undefined;
     // Sender-side cached shadow of the receiver-owned queue word. Under the XSC
     // 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);
@@ -487,7 +572,12 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         deferredCount = 0 | 0;
         return toBeSent.isEmpty;
     };
-    const storeHost = (bit) => a_store(hostBits, 0, LastLocal = (LastLocal ^ bit) | 0);
+    const storeHost = (bit) => {
+        a_store(hostBits, 0, LastLocal = (LastLocal ^ bit) | 0);
+        if (shouldNotifyHostPublish && a_load(doorbellArmed, 0) !== 0) {
+            a_notify(hostBits, 0, 1);
+        }
+    };
     const storeWorker = (bit) => a_store(workerBits, 0, LastWorker = (LastWorker ^ bit) | 0);
     const encode = (task, state = (LastLocal ^ workerShadow) | 0) => {
         state = ensureSenderStateHasFree(state);
@@ -561,6 +651,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
      */
@@ -689,6 +895,34 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
             return modified;
         };
     };
+    /**
+     * HOST SIDE: wait until the producer changes hostBits.
+     *
+     * LastWorker is the host's acknowledgement shadow. Passing it as the
+     * expected value makes the arm race-free: a publication between the drain
+     * and this call returns `not-equal` synchronously instead of being lost.
+    */
+    const waitForHostChange = (timeoutMs) => {
+        if (a_waitAsync === undefined) {
+            a_store(doorbellArmed, 0, 0);
+            return undefined;
+        }
+        a_store(doorbellArmed, 0, 1);
+        try {
+            const wait = a_waitAsync(hostBits, 0, LastWorker | 0, timeoutMs);
+            if (!wait.async)
+                a_store(doorbellArmed, 0, 0);
+            return wait;
+        }
+        catch {
+            a_store(doorbellArmed, 0, 0);
+            // Some runtimes reject particular SharedArrayBuffer implementations
+            // (for example a growable or native-backed buffer). Fall back to the
+            // existing dispatcher rather than turning a capability issue into a
+            // hung pool.
+            return undefined;
+        }
+    };
     const decodeAt = (at) => {
         const off = (at * headersSlotStride) + slotBaseU32;
         const recycled = recycleShift();
@@ -730,6 +964,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,17 +989,22 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
         encodeAll,
         publish,
         flushPending,
-        decode,
+        decode: stealEnabled ? decodeSteal : decode,
         hasSpace,
         resolved,
         hostBits,
         workerBits,
         recyclecList,
         resolveHost,
+        waitForHostChange,
+        setHostWaiterArmed: (armed) => {
+            a_store(doorbellArmed, 0, armed ? 1 : 0);
+        },
         hasPendingFrames: () => toBeSent.size !== 0,
         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;

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.d.ts

@@ -2,12 +2,14 @@ import { type MultiQueue } from "./tx-queue.js";
 import { type MainSignal } from "../ipc/transport/shared-memory.js";
 import { type RuntimeMessageChannelLike, type RuntimeMessagePortLike } from "../common/worker-runtime.js";
 import type { DispatcherSettings } from "../types.js";
-export declare const hostDispatcherLoop: ({ signalBox: { opView, txStatus, rxStatus, }, queue: { completeFrame, hasPendingFrames, flushToWorker, txIdle, }, channelHandler, dispatcherOptions, notifySignal, }: {
+export declare const hostDispatcherLoop: ({ signalBox: { opView, txStatus, rxStatus, }, queue: { completeFrame, hasPendingFrames, flushToWorker, txIdle, waitForCompletion, setCompletionWaiterArmed, }, channelHandler, dispatcherOptions, notifySignal, crossProcess, }: {
     queue: MultiQueue;
     signalBox: MainSignal;
     channelHandler: ChannelHandler;
     dispatcherOptions?: DispatcherSettings;
     notifySignal?: () => void;
+    /** Workers live in other processes; disables the doorbell. */
+    crossProcess?: boolean;
 }) => {
     check: {
         (): void;
@@ -20,20 +22,21 @@ type CheckWithState = (() => void) & {
     rerun: boolean;
 };
 export type DispatcherCheck = CheckWithState;
+export type ChannelHandlerPump = "auto" | "channel";
 export declare class ChannelHandler {
     #private;
-    channel: RuntimeMessageChannelLike;
-    port1: RuntimeMessagePortLike;
-    port2: RuntimeMessagePortLike;
-    constructor();
+    channel: RuntimeMessageChannelLike | undefined;
+    port1: RuntimeMessagePortLike | undefined;
+    port2: RuntimeMessagePortLike | undefined;
+    constructor(pump?: ChannelHandlerPump);
     notify(): void;
     /**
-     * Opens the channel (if not already open) and sets the onmessage handler.
-     * This is the setup so `notify` can send a message to the port 1.
+     * Registers the handler the pump calls back into. On the channel pump this is
+     * also where the ports are opened, so `notify` can reach port 1.
      */
     open(f: () => void): void;
     /**
-     * Closes the channel if it is open.
+     * Detaches the handler, and closes the channel if this pump has one.
      */
     close(): void;
 }