knitting 0.1.62 → 0.1.70

package/src/runtime/pool.js

@@ -1,27 +1,33 @@
 import { createHostTxQueue } from "./tx-queue.js";
-import { cleanupProcessWorkerMemoryQuietly, createProcessSharedMemoryAllocator, createProcessStealMemoryLayout, createProcessWorkerMemoryLayout, createProcessWorkerNativeSignalNotifier, readProcessSharedMemorySettings, readProcessWorkerCommandPrefix, readProcessWorkerRuntime, spawnProcessWorker, toProcessWorkerBootPayload, } from "./process-worker.js";
+import { cleanupProcessWorkerMemoryQuietly, createProcessSharedMemoryAllocator, createProcessStealMemoryLayout, createProcessWorkerMemoryLayout, createProcessWorkerNativeSignalNotifier, processWorkerUsesIpc, 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 { createSharedMemoryTransport, TRANSPORT_SIGNAL_BYTES, WORKER_STOP, } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, hostDispatcherLoop, } from "./dispatcher.js";
+import { createNodeCompletionDoorbell } from "./node-doorbell.js";
 import { HEADER_SLOT_STRIDE_U32, lock2, LOCK_SECTOR_BYTE_LENGTH, LockBound, } from "../memory/lock.js";
-// Side-effect import: registers the payload codec (cycle break for Andromeda;
-// see lock.ts). Must run before any lock2() call.
+// Registers the payload codec before any lock is built.
 import "../memory/payloadCodec.js";
 import "../worker/loop.js";
 import { createSharedArrayBuffer, createWasmSharedArrayBuffer, IS_BROWSER, RUNTIME, } from "../common/runtime.js";
-import { HAS_NODE_WORKER_THREADS, RUNTIME_WORKER, } from "../common/worker-runtime.js";
+import { HAS_NODE_WORKER_THREADS, isProcessCompletionDoorbell, RUNTIME_WORKER, } from "../common/worker-runtime.js";
 import { probeLockBufferTextCompat } from "../common/shared-buffer-text.js";
 import { signalAbortFactory } from "../shared/abortSignal.js";
 import { createLockControlCarpet } from "../memory/byte-carpet.js";
 import { resolvePayloadBufferOptions, } from "../memory/payload-config.js";
-import { createBufferReferenceReturnReleaseMessage, detachArrayBufferBestEffort, } from "../connections/buffer-reference.js";
 import { spawnCompiledWorkerContext } from "./compiled-worker.js";
 const WORKER_FATAL_MESSAGE_KEY = "__knittingWorkerFatal";
 const isWorkerFatalMessage = (value) => !!value &&
     typeof value === "object" &&
     typeof value[WORKER_FATAL_MESSAGE_KEY] === "string";
+// Bound the wait for a worker to acknowledge loop exit.
+const WORKER_STOP_ACK_TIMEOUT_MS = 50;
+// Node owns returned BufferReference backing stores in a process-global native
+// registry. Give its worker loop a chance to drain deferred producer pins
+// before the host falls back to terminate().
+const WORKER_STOP_NEEDS_ACK = RUNTIME === "deno" || RUNTIME === "node";
 // Keep idle workers self-healing if an Atomics.notify wake is missed.
 const DEFAULT_WORKER_PARK_MS = 1;
+const SINGLE_WORKER_SPIN_US = 50;
 const DEFAULT_ABORT_SIGNAL_CAPACITY = 258;
 const sanitizePositiveInteger = (value) => {
     if (!Number.isFinite(value))
@@ -31,15 +37,20 @@ const sanitizePositiveInteger = (value) => {
 };
 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 withDefaultWorkerTimers = (options, workerCount) => {
     const parkMs = options?.timers?.parkMs ?? DEFAULT_WORKER_PARK_MS;
+    // `??` and not `||`: an explicit `spinMicroseconds: 0` is the whole point of
+    // the multi-worker default and must not fall through to it.
+    const spinMicroseconds = options?.timers?.spinMicroseconds ??
+        (workerCount <= 1 ? SINGLE_WORKER_SPIN_US : 0);
     if (options === undefined)
-        return { timers: { parkMs } };
+        return { timers: { parkMs, spinMicroseconds } };
     return {
         ...options,
         timers: {
             ...options.timers,
             parkMs,
+            spinMicroseconds,
         },
     };
 };
@@ -48,16 +59,7 @@ const withFixedPayloadConfig = (config) => ({
     mode: "fixed",
     payloadInitialBytes: config.payloadMaxByteLength,
 });
-/**
- * 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.
- */
+/** Build the shared submit and private return buffers for a stealing pool. */
 export const resolveStealRegionLanes = (consumers) => {
     for (let lanes = LockBound.slots; lanes >= 1; lanes >>= 1) {
         if (LockBound.slots / lanes >= consumers + 1)
@@ -65,9 +67,13 @@ export const resolveStealRegionLanes = (consumers) => {
     }
     throw new RangeError(`${consumers} stealing workers need more than ${LockBound.slots} lanes`);
 };
+/** Return the widest region allowed by the selected claim discipline. */
+export const resolveMaxStealRegionLanes = (consumers, stealClaim) => stealClaim !== undefined && stealClaim !== "dekker"
+    ? LockBound.slots
+    : resolveStealRegionLanes(consumers);
 /** 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, processWorker, }) => {
+export const createStealPoolBuffers = ({ threads, payload, sharedArgs, regionLanes, stealClaim, abortSignalCapacity, usesAbortSignal, processWorker, }) => {
     const basePayloadConfig = resolvePayloadBufferOptions({ options: payload });
     const payloadConfig = processWorker === undefined
         ? basePayloadConfig
@@ -91,9 +97,10 @@ export const createStealPoolBuffers = ({ threads, payload, regionLanes, abortSig
             payload: payloadSab,
         }),
     });
-    const maxLanes = resolveStealRegionLanes(threads);
+    // Keep the default width valid for Dekker; wider CAS-mask regions are explicit.
+    const maxLanes = resolveMaxStealRegionLanes(threads, stealClaim);
     const lanes = regionLanes === undefined
-        ? maxLanes
+        ? resolveStealRegionLanes(threads)
         : Math.min(Math.max(1, regionLanes | 0), maxLanes);
     const resolvedAbortSignalCapacity = resolveAbortSignalCapacity(abortSignalCapacity);
     const processMemory = processWorker === undefined ? undefined : createProcessStealMemoryLayout({
@@ -124,7 +131,11 @@ export const createStealPoolBuffers = ({ threads, payload, regionLanes, abortSig
         textCompat: submitBuffers.textCompat,
         consumers: threads,
         regionLanes: lanes,
+        stealClaim,
         processBoundary: processMemory !== undefined,
+        // Shared arguments are opt-in because the receiving task may outlive the
+        // borrowed region.
+        sharedReturn: sharedArgs === true,
     });
     const returnBuffers = [];
     const hostReturnLocks = [];
@@ -170,13 +181,14 @@ export const createStealPoolBuffers = ({ threads, payload, regionLanes, abortSig
         hostReturnLocks,
         sharedQueue,
         regionLanes: lanes,
+        stealClaim,
         processMemory,
         abortSignalSAB,
         abortSignalMax: processMemory?.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, }) => {
+export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, workerCount, source, at, workerOptions, workerExecArgv, permission, host, payload, sharedBytesEnabled, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, denoCompletionDoorbell, stealPool, }) => {
     if (workerOptions?.runtime === "compiled") {
         return spawnCompiledWorkerContext({
             list,
@@ -189,14 +201,22 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     }
     const tsFileUrl = new URL(import.meta.url);
     const poliWorker = RUNTIME_WORKER;
-    const resolvedWorkerOptions = serializeWorkerBootstrapData(withDefaultWorkerTimers(workerOptions));
+    const resolvedWorkerOptions = serializeWorkerBootstrapData(withDefaultWorkerTimers(workerOptions, workerCount ?? totalNumberOfThread));
     const useProcessWorkerRuntime = resolvedWorkerOptions.runtime === "process";
+    const canUseDenoCompletionDoorbell = !useProcessWorkerRuntime &&
+        denoCompletionDoorbell !== undefined;
     const processWorkerRuntime = useProcessWorkerRuntime
         ? readProcessWorkerRuntime(resolvedWorkerOptions)
         : undefined;
     const processWorkerCommandPrefix = useProcessWorkerRuntime
         ? readProcessWorkerCommandPrefix(resolvedWorkerOptions)
         : undefined;
+    const canUseProcessCompletionDoorbell = useProcessWorkerRuntime &&
+        host?.doorbell !== false &&
+        processWorkerUsesIpc({
+            processRuntime: processWorkerRuntime,
+            commandPrefix: processWorkerCommandPrefix,
+        });
     const processSharedMemorySettings = useProcessWorkerRuntime
         ? readProcessSharedMemorySettings(resolvedWorkerOptions)
         : undefined;
@@ -229,10 +249,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     const abortBytes = stealPool === undefined && usesAbortSignal === true
         ? abortSignalByteLength(resolvedAbortSignalCapacity)
         : 0;
-    // A stealing process pool carves every lane out of one mapping, so lane
-    // `thread` must find its slice there. Falling back to a private layout would
-    // silently give this lane its own submit region — it would boot and then
-    // never see a task the host published to the shared one.
+    // Stealing process workers use their slice of the pool-wide mapping.
     const stealProcessMemory = stealPool?.processMemory;
     const processWorkerMemory = !useProcessWorkerRuntime
         ? undefined
@@ -255,18 +272,14 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         createWasmSharedArrayBuffer;
     const createPayloadBuffer = processSharedMemory?.createBuffer;
     const makePayloadBuffer = () => createPayloadBuffer
-        // ProcessSharedBuffer is fixed-size today, so reserve the configured
-        // payload ceiling instead of relying on SAB growth.
+        // Process-shared buffers are fixed-size.
         ? createPayloadBuffer(resolvedPayloadConfig.payloadMaxByteLength)
         : resolvedPayloadConfig.mode === "growable"
             ? createSharedArrayBuffer(resolvedPayloadConfig.payloadInitialBytes, resolvedPayloadConfig.payloadMaxByteLength)
             : createSharedArrayBuffer(resolvedPayloadConfig.payloadInitialBytes);
     const makeLockControlLayout = () => {
-        // Keep the hottest control words in one compact front strip:
-        // transport signals -> request lock -> return lock.
-        // Request/return headers stay in separate contiguous slabs to preserve
-        // sequential batching locality.
-        // Abort bitmap stays at the tail.
+        // Place hot control words first; keep headers contiguous and the abort bitmap
+        // at the tail.
         return createLockControlCarpet({
             signalBytes,
             abortBytes,
@@ -341,68 +354,11 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         processRuntime: processWorkerRuntime,
         signal: signalBox.opView,
     });
-    const outstandingBorrowedReturns = bufferReferenceReturn === "borrow" && typeof WeakRef === "function"
-        ? new Map()
-        : undefined;
-    const releaseBorrowedReturnToken = (token) => {
-        outstandingBorrowedReturns?.delete(token);
-        worker?.postMessage?.(createBufferReferenceReturnReleaseMessage(token));
-    };
-    const revokeOutstandingBorrowedReturns = (copyBytes) => {
-        if (outstandingBorrowedReturns === undefined)
-            return;
-        for (const [token, record] of outstandingBorrowedReturns) {
-            try {
-                const ref = record.ref.deref();
-                if (ref !== undefined) {
-                    ref.revokeBorrow(copyBytes);
-                    continue;
-                }
-                const aliasBuffer = record.aliasBuffer?.deref();
-                if (aliasBuffer !== undefined &&
-                    detachArrayBufferBestEffort(record.runtime, aliasBuffer) &&
-                    copyBytes) {
-                    releaseBorrowedReturnToken(token);
-                }
-            }
-            catch {
-                // best effort
-            }
-        }
-        outstandingBorrowedReturns.clear();
-    };
-    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: returnHooks,
     });
-    if (stealPool !== undefined) {
-        stealPool.sharedQueue.setReturnHooks(stealPool.consumerId, returnHooks);
-    }
     const { enqueue, rejectAll, txIdle, } = queue;
     const thisSignal = signalBox.opView;
     const a_add = Atomics.add;
@@ -411,8 +367,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     const canNotifySignal = thisSignal.buffer instanceof SharedArrayBuffer;
     const notifySignal = nativeNotifySignal ??
         (canNotifySignal ? (() => a_notify(thisSignal, 0, 1)) : undefined);
-    // Wakes this lane's worker when it is parked (rxStatus 0). Used by send()
-    // (new work just arrived) — the dispatcher drain wakes it the same way.
+    // Wake this lane when its worker is parked.
     const laneWake = () => {
         if (a_load(signalBox.rxStatus, 0) === 0) {
             a_add(thisSignal, 0, 1);
@@ -425,10 +380,16 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
     const ownsChannel = sharedChannelHandler === undefined &&
         stealPool === undefined;
     const ownChannel = sharedChannelHandler ?? new ChannelHandler();
-    // 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 }
+    // Create the Node doorbell before bootstrapping the worker.
+    let nodeCompletionWake;
+    const nodeCompletionDoorbell = !useProcessWorkerRuntime &&
+        host?.doorbell !== false && host?.nativeDoorbell === true
+        ? createNodeCompletionDoorbell(() => nodeCompletionWake?.())
+        : undefined;
+    const canUseNodeCompletionDoorbell = nodeCompletionDoorbell !== undefined;
+    // A stealing pool has one dispatcher for its shared queue.
+    const { check: dispatcherCheck, wakeCompletion: directCompletionWake, } = stealPool !== undefined
+        ? { check: undefined, wakeCompletion: undefined }
         : hostDispatcherLoop({
             signalBox,
             queue,
@@ -436,7 +397,15 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
             dispatcherOptions: host,
             notifySignal: nativeNotifySignal,
             crossProcess: useProcessWorkerRuntime,
+            nativeCompletionDoorbell: canUseDenoCompletionDoorbell ||
+                canUseNodeCompletionDoorbell,
+            processCompletionDoorbell: canUseProcessCompletionDoorbell,
         });
+    if (canUseDenoCompletionDoorbell && dispatcherCheck !== undefined) {
+        denoCompletionDoorbell.listen(thread, directCompletionWake);
+    }
+    nodeCompletionWake = directCompletionWake;
+    let processCompletionWake = directCompletionWake;
     if (ownsChannel && dispatcherCheck !== undefined) {
         ownChannel.open(dispatcherCheck);
         channelHandler = ownChannel;
@@ -444,7 +413,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
             if (dispatcherCheck.isRunning === true)
                 return;
             dispatcherCheck.isRunning = true;
-            Promise.resolve().then(dispatcherCheck);
+            queueMicrotask(dispatcherCheck);
             laneWake();
         };
     }
@@ -475,18 +444,27 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         lock: lockBuffers,
         returnLock: returnLockBuffers,
         payloadConfig: resolvedPayloadConfig,
-        bufferReferenceReturn,
+        sharedReturn: sharedBytesEnabled === true,
         permission,
-        // Mirrors the dispatcher's `canUseDoorbell`: a cross-process worker cannot
-        // ring the host's waiter, so do not make it pay the atomic op.
-        notifyOnHostPublish: !useProcessWorkerRuntime &&
-            host?.doorbell !== false &&
-            (RUNTIME === "bun" || RUNTIME === "node") &&
-            typeof Atomics.waitAsync === "function",
+        // Select the completion doorbell supported by the worker runtime.
+        notifyOnHostPublish: host?.doorbell !== false &&
+            (canUseProcessCompletionDoorbell ||
+                canUseNodeCompletionDoorbell ||
+                (!useProcessWorkerRuntime &&
+                    (RUNTIME === "bun" || RUNTIME === "node") &&
+                    typeof Atomics.waitAsync === "function")),
+        processCompletionDoorbell: canUseProcessCompletionDoorbell,
+        denoCompletionDoorbell: canUseDenoCompletionDoorbell
+            ? denoCompletionDoorbell.pointer
+            : undefined,
+        nodeCompletionDoorbell: canUseNodeCompletionDoorbell
+            ? nodeCompletionDoorbell.pointer
+            : undefined,
         steal: stealPool === undefined ? undefined : {
             consumers: stealPool.consumers,
             consumerId: stealPool.consumerId,
             regionLanes: stealPool.regionLanes,
+            claim: stealPool.stealClaim,
         },
     };
     const baseWorkerOptions = {
@@ -556,6 +534,11 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         worker.postMessage?.(workerDataPayload);
     }
     let closedReason;
+    // A worker that exits because the host asked it to stop is a closed thread,
+    // not a crash. The stop is acknowledged in shared memory before the worker
+    // unwinds, so on a slow host the `exit` event can land ahead of `kills()`
+    // and label an orderly shutdown "Worker exited with code 0".
+    let stopRequested = false;
     const deactivateStealConsumer = () => {
         stealPool?.hostSubmitLock.deactivateStealConsumer(stealPool.consumerId);
     };
@@ -570,21 +553,21 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
             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.
-    const markWorkerClosed = (reason, workerBytesReadable = false) => {
+    const markWorkerClosed = (reason) => {
         if (closedReason)
             return;
         closedReason = reason;
-        revokeOutstandingBorrowedReturns(workerBytesReadable);
         rejectAll(reason);
         channelHandler?.close();
     };
     const onWorkerMessage = (message) => {
+        if (isProcessCompletionDoorbell(message)) {
+            processCompletionWake?.();
+            return;
+        }
         if (!isWorkerFatalMessage(message))
             return;
-        markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`, true);
+        markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`);
         terminateFailedWorker();
     };
     const onWorkerError = (error) => {
@@ -597,11 +580,14 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         nodeWorker.on("message", onWorkerMessage);
         nodeWorker.on("error", onWorkerError);
         nodeWorker.on("exit", (code) => {
-            // Exit is the point at which this endpoint can no longer write WANT, so
-            // survivors may safely ignore any intent it left behind.
             deactivateStealConsumer();
+            nodeCompletionDoorbell?.close();
             if (closedReason !== undefined)
                 return;
+            if (stopRequested) {
+                markWorkerClosed("Thread closed");
+                return;
+            }
             const normalized = typeof code === "number" ? code : -1;
             markWorkerClosed(`Worker exited with code ${normalized}`);
         });
@@ -637,13 +623,39 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
             return pending;
         };
     };
+    const requestWorkerStop = async () => {
+        stopRequested = true;
+        const stopView = signalBox.stopView;
+        if (stopView === undefined)
+            return true;
+        try {
+            Atomics.store(stopView, 0, WORKER_STOP.requested);
+            laneWake();
+            notifySignal?.();
+        }
+        catch {
+            return false;
+        }
+        if (!WORKER_STOP_NEEDS_ACK)
+            return true;
+        const deadline = Date.now() + WORKER_STOP_ACK_TIMEOUT_MS;
+        while (Atomics.load(stopView, 0) !== WORKER_STOP.acknowledged) {
+            if (Date.now() >= deadline)
+                return false;
+            await new Promise((resolve) => setTimeout(resolve, 1));
+        }
+        return true;
+    };
     const context = {
         txIdle,
         call,
+        requestStop: requestWorkerStop,
         kills: async () => {
-            markWorkerClosed("Thread closed", true);
-            const termination = terminateWorkerQuietly(worker);
-            if (processWorkerMemory !== undefined)
+            markWorkerClosed("Thread closed");
+            // Process workers must exit before their shared memory is unmapped.
+            const awaitExit = processWorkerMemory !== undefined;
+            const termination = terminateWorkerQuietly(worker, awaitExit);
+            if (awaitExit)
                 await termination;
             cleanupProcessWorkerMemoryQuietly(processWorkerMemory);
         },
@@ -656,6 +668,16 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         bindSend: sharedChannelHandler !== undefined || stealPool !== undefined
             ? ((fn) => void (dispatchSend = fn))
             : undefined,
+        bindCompletionWake: (canUseProcessCompletionDoorbell ||
+            canUseNodeCompletionDoorbell) &&
+            stealPool !== undefined
+            ? ((fn) => {
+                processCompletionWake = fn;
+                nodeCompletionWake = fn;
+            })
+            : undefined,
+        processCompletionDoorbell: canUseProcessCompletionDoorbell,
+        nodeCompletionDoorbell: canUseNodeCompletionDoorbell,
     };
     return context;
 };

package/src/runtime/process-worker.d.ts

@@ -92,6 +92,15 @@ export declare const createProcessWorkerNativeSignalNotifier: ({ processRuntime,
     processRuntime: ProcessWorkerRuntime | undefined;
     signal: Int32Array;
 }) => (() => void) | undefined;
+/**
+ * Whether this host/child pair has the Node-compatible IPC channel that the
+ * process completion-doorbell prototype uses. Deno process workers currently
+ * boot through environment data and do not have that channel.
+ */
+export declare const processWorkerUsesIpc: ({ processRuntime, commandPrefix, }: {
+    processRuntime: ProcessWorkerRuntime | undefined;
+    commandPrefix?: ProcessWorkerCommandPrefix;
+}) => boolean;
 export declare const spawnProcessWorker: (options: {
     workerUrl: string | URL;
     bootPayload: ProcessWorkerBootPayload;

package/src/runtime/process-worker.js

@@ -109,6 +109,13 @@ const isWindowsRuntimeHost = () => {
         return denoOs === "windows";
     return globalThis.process?.platform === "win32";
 };
+const processWorkerNeedsNamedMemory = (sharedMemory) => 
+// `Deno.Command` does not reliably carry an anonymous memfd/shm fd into a
+// child as stdin: Linux can hand the child a non-mappable descriptor and
+// macOS cannot always reopen the host fd through `/dev/fd`. Named mappings
+// are reopened by the worker instead, which works across Deno's supported
+// hosts and process-worker runtimes.
+sharedMemory.mode === "named" || isWindowsRuntimeHost() || RUNTIME === "deno";
 let processWorkerMemoryNameCounter = 0;
 const makeProcessWorkerMemoryName = (thread, prefix = "kpw") => {
     const processId = globalThis.process?.pid ??
@@ -142,7 +149,7 @@ export const createProcessWorkerMemoryLayout = ({ signalBytes, abortBytes, paylo
     const requestPayloadSlice = carpet.take("requestPayload", payloadBytes);
     const returnPayloadSlice = carpet.take("returnPayload", payloadBytes);
     const primitives = getProcessWorkerSharedMemoryPrimitives();
-    const forceNamed = sharedMemory.mode === "named" || isWindowsRuntimeHost();
+    const forceNamed = processWorkerNeedsNamedMemory(sharedMemory);
     const mapping = primitives.createSharedMemory(forceNamed
         ? {
             size: carpet.byteLength(),
@@ -215,7 +222,7 @@ export const createProcessStealMemoryLayout = ({ threads, signalBytes, abortByte
         returnPayload: carpet.take(`returnPayload-${thread}`, payloadBytes),
     }));
     const primitives = getProcessWorkerSharedMemoryPrimitives();
-    const forceNamed = sharedMemory.mode === "named" || isWindowsRuntimeHost();
+    const forceNamed = processWorkerNeedsNamedMemory(sharedMemory);
     const mapping = primitives.createSharedMemory(forceNamed
         ? {
             size: carpet.byteLength(),
@@ -546,6 +553,19 @@ export const createProcessWorkerNativeSignalNotifier = ({ processRuntime, signal
         return undefined;
     }
 };
+/**
+ * Whether this host/child pair has the Node-compatible IPC channel that the
+ * process completion-doorbell prototype uses. Deno process workers currently
+ * boot through environment data and do not have that channel.
+ */
+export const processWorkerUsesIpc = ({ processRuntime, commandPrefix, }) => {
+    if (processRuntime === undefined || commandPrefix !== undefined)
+        return false;
+    if (RUNTIME === "node") {
+        return processRuntime === "node" || processRuntime === "bun";
+    }
+    return RUNTIME === "bun" && processRuntime === "bun";
+};
 const createProcessWorkerEventHub = () => {
     const messageHandlers = [];
     const errorHandlers = [];

package/src/runtime/tx-queue.d.ts

@@ -2,7 +2,6 @@ import "../memory/payloadCodec.js";
 import { type Lock2, type Task } from "../memory/lock.js";
 import type { AbortSignalOption, TaskTimeout } from "../types.js";
 import { type SignalAbortStore } from "../shared/abortSignal.js";
-import { type BufferReferenceReturnHooks } from "../connections/buffer-reference.js";
 type RawArguments = unknown;
 type FunctionID = number;
 type QueueTask = Task;
@@ -23,19 +22,17 @@ type CreateHostTxQueueArgs = {
      * When omitted, only `returnLock` is drained (the classic one-lane shape).
      */
     extraReturnLocks?: readonly Lock2[];
-    releaseBufferReferenceReturn?: ((token: bigint) => void) | BufferReferenceReturnHooks;
     abortSignals?: Pick<SignalAbortStore, "getSignal" | "setSignal" | "resetSignal" | "closeNow">;
     now?: () => number;
 };
-type ReturnHooks = ((token: bigint) => void) | BufferReferenceReturnHooks;
-export declare function createHostTxQueue({ max, lock, returnLock, extraReturnLocks, releaseBufferReferenceReturn, abortSignals, now, }: CreateHostTxQueueArgs): {
+export declare function createHostTxQueue({ max, lock, returnLock, extraReturnLocks, abortSignals, now, }: CreateHostTxQueueArgs): {
     rejectAll: (reason: string) => void;
     hasPendingFrames: () => boolean;
     txIdle: () => boolean;
     completeFrame: () => number;
     waitForCompletion: (onWake: () => void, timeoutMs?: number) => boolean;
+    armCompletionNotifier: () => boolean;
     setCompletionWaiterArmed: (armed: boolean) => void;
-    setReturnHooks: (lane: number, hooks: ReturnHooks | undefined) => void;
     enqueue: (functionID: FunctionID, timeout?: TaskTimeout, abortSignal?: AbortSignalOption) => (rawArgs: RawArguments) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
     flushToWorker: () => boolean;
     enqueueKnown: (task: QueueTask) => boolean;