knitting 0.1.60 → 0.1.62

package/src/runtime/process-worker.js

@@ -2,6 +2,7 @@ import { HEADER_SLOT_STRIDE_U32, LOCK_SECTOR_BYTE_LENGTH, LockBound, } from "../
 import { createByteCarpet, getHeaderBlockByteLength, makeSharedBufferRegion, } from "../memory/byte-carpet.js";
 import { RUNTIME } from "../common/runtime.js";
 import { debugHas } from "../debug/gate.js";
+import { toWorkerCompatExecArgv, } from "./worker-common.js";
 import { RUNTIME_POOL_DEPTH, RUNTIME_POOL_DEPTH_ENV, RUNTIME_PROCESS_WORKER_BOOT_ENV, RUNTIME_PROCESS_WORKER_BOOT_VERSION, RUNTIME_PROCESS_WORKER_ENV, } from "../common/worker-runtime.js";
 import { getNodeBuiltinModule, getNodeProcess } from "../common/node-compat.js";
 import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
@@ -20,51 +21,6 @@ const fileURLToPathCompat = (value) => {
     }
     return url.fileURLToPath(value);
 };
-const execFlagKey = (flag) => flag.split("=", 1)[0];
-const NODE_PERMISSION_EXEC_FLAGS = new Set([
-    "--permission",
-    "--experimental-permission",
-    "--allow-fs-read",
-    "--allow-fs-write",
-    "--allow-worker",
-    "--allow-child-process",
-    "--allow-net",
-    "--allow-addons",
-    "--allow-ffi",
-    "--allow-wasi",
-]);
-const NODE_WORKER_SAFE_EXEC_FLAGS = new Set([
-    "--experimental-ffi",
-    "--experimental-transform-types",
-    "--expose-gc",
-    "--no-warnings",
-    ...NODE_PERMISSION_EXEC_FLAGS,
-]);
-const isNodeWorkerSafeExecFlag = (flag) => NODE_WORKER_SAFE_EXEC_FLAGS.has(execFlagKey(flag));
-const isNodePermissionExecFlag = (flag) => NODE_PERMISSION_EXEC_FLAGS.has(execFlagKey(flag));
-export const toWorkerSafeExecArgv = (flags) => {
-    if (!flags || flags.length === 0)
-        return undefined;
-    const filtered = flags.filter(isNodeWorkerSafeExecFlag);
-    if (filtered.length === 0)
-        return undefined;
-    const seen = new Set();
-    const deduped = [];
-    for (const flag of filtered) {
-        if (seen.has(flag))
-            continue;
-        seen.add(flag);
-        deduped.push(flag);
-    }
-    return deduped;
-};
-export const toWorkerCompatExecArgv = (flags) => {
-    const safe = toWorkerSafeExecArgv(flags);
-    if (!safe || safe.length === 0)
-        return undefined;
-    const compat = safe.filter((flag) => !isNodePermissionExecFlag(flag));
-    return compat.length > 0 ? compat : undefined;
-};
 const toProcessSharedMemorySize = (byteLength) => {
     if (!Number.isFinite(byteLength) || byteLength <= 0) {
         throw new RangeError("process shared memory byteLength must be positive");
@@ -118,19 +74,18 @@ const DENO_PROCESS_WORKER_INTERNAL_FLAGS = [
     `--allow-env=${DENO_PROCESS_WORKER_BOOT_ENV_ALLOW}`,
     "--allow-ffi",
 ];
-const nodeMajorVersion = () => {
-    const version = getNodeProcess()?.versions?.node ?? "";
-    const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
-    return Number.isInteger(major) ? major : 0;
-};
-const nodeProcessWorkerUsesFfi = () => {
-    const major = nodeMajorVersion();
-    return major >= 26 && major % 2 === 0;
+const parseNodeMajorVersion = (version) => {
+    const match = /^v?(\d+)/.exec(String(version).trim());
+    if (match === null)
+        return undefined;
+    const major = Number.parseInt(match[1], 10);
+    return Number.isInteger(major) && major > 0 ? major : undefined;
 };
-const nodeProcessWorkerInternalExecArgv = () => {
+const nodeProcessWorkerUsesFfi = (nodeMajor) => nodeMajor !== undefined && nodeMajor >= 26 && nodeMajor % 2 === 0;
+const nodeProcessWorkerInternalExecArgv = (nodeMajor) => {
     return [
         "--no-warnings",
-        ...(nodeProcessWorkerUsesFfi()
+        ...(nodeProcessWorkerUsesFfi(nodeMajor)
             ? ["--experimental-ffi"]
             : ["--experimental-transform-types"]),
     ];
@@ -236,6 +191,106 @@ export const createProcessWorkerMemoryLayout = ({ signalBytes, abortBytes, paylo
         },
     };
 };
+export const createProcessStealMemoryLayout = ({ threads, signalBytes, abortBytes, abortSignalMax, payloadBytes, sharedMemory, }) => {
+    if (!Number.isInteger(threads) || threads < 2) {
+        throw new RangeError("process stealing needs at least two workers");
+    }
+    const carpet = createByteCarpet();
+    const requestLockSlice = carpet.take("requestLockSector", LOCK_SECTOR_BYTE_LENGTH);
+    const requestHeadersSlice = carpet.take("requestHeaders", getHeaderBlockByteLength({
+        slotCount: LockBound.slots,
+        slotStrideU32: HEADER_SLOT_STRIDE_U32,
+        alignTo: 64,
+    }));
+    const abortSignalsSlice = carpet.take("abortSignals", abortBytes);
+    const requestPayloadSlice = carpet.take("requestPayload", payloadBytes);
+    const workerSlices = Array.from({ length: threads }, (_, thread) => ({
+        signal: carpet.take(`signals-${thread}`, signalBytes),
+        returnLock: carpet.take(`returnLockSector-${thread}`, LOCK_SECTOR_BYTE_LENGTH),
+        returnHeaders: carpet.take(`returnHeaders-${thread}`, getHeaderBlockByteLength({
+            slotCount: LockBound.slots,
+            slotStrideU32: HEADER_SLOT_STRIDE_U32,
+            alignTo: 64,
+        })),
+        returnPayload: carpet.take(`returnPayload-${thread}`, payloadBytes),
+    }));
+    const primitives = getProcessWorkerSharedMemoryPrimitives();
+    const forceNamed = sharedMemory.mode === "named" || isWindowsRuntimeHost();
+    const mapping = primitives.createSharedMemory(forceNamed
+        ? {
+            size: carpet.byteLength(),
+            mode: "create",
+            name: makeProcessWorkerMemoryName(0, sharedMemory.namePrefix),
+        }
+        : { size: carpet.byteLength() });
+    const descriptor = FileDescriptor.fromMapping(mapping);
+    if (isWindowsRuntimeHost() && descriptor.name === undefined) {
+        throw new Error("Windows process worker shared memory must use a named mapping");
+    }
+    if (sharedMemory.mode === "named" && descriptor.name === undefined) {
+        throw new Error("processSharedMemory mode named needs a named shared-memory backend");
+    }
+    const buffer = mapping.buffer;
+    const bind = (slice) => makeSharedBufferRegion(buffer, slice.byteOffset, slice.byteLength);
+    const abortSignals = bind(abortSignalsSlice);
+    const requestLock = {
+        headers: bind(requestHeadersSlice),
+        headerSlotStrideU32: HEADER_SLOT_STRIDE_U32,
+        lockSector: bind(requestLockSlice),
+        payloadSector: bind(requestLockSlice),
+    };
+    // Each worker calls cleanup, so named-memory unlink happens only after every
+    // endpoint has released its view. The per-worker mapping wrappers below do
+    // not expose close(); the host views remain attached until host exit because
+    // Bun's external ArrayBuffer finalizer can race an explicit munmap.
+    let remaining = threads;
+    let cleaned = false;
+    const cleanupSharedMapping = () => {
+        if (cleaned)
+            return;
+        remaining--;
+        if (remaining > 0)
+            return;
+        cleaned = true;
+        const name = descriptor.name;
+        if (name !== undefined && sharedMemory.unlinkOnShutdown) {
+            primitives.unlinkSharedMemory?.(name);
+        }
+    };
+    const workerMapping = {
+        ...mapping,
+        close: undefined,
+    };
+    const workers = workerSlices.map((slices) => {
+        const returnLock = {
+            headers: bind(slices.returnHeaders),
+            headerSlotStrideU32: HEADER_SLOT_STRIDE_U32,
+            lockSector: bind(slices.returnLock),
+            payloadSector: bind(slices.returnLock),
+        };
+        return {
+            mapping: workerMapping,
+            descriptor,
+            controlLayout: {
+                controlSAB: buffer,
+                signals: bind(slices.signal),
+                abortSignals,
+                lock: requestLock,
+                returnLock,
+                slices: carpet.slices,
+            },
+            lockPayload: bind(requestPayloadSlice),
+            returnPayload: bind(slices.returnPayload),
+            cleanup: cleanupSharedMapping,
+        };
+    });
+    return {
+        mapping,
+        descriptor,
+        workers,
+        abortSignalMax,
+    };
+};
 const toChildProcessSharedBufferMetadata = (source, descriptor) => {
     const region = toSharedBufferRegion(source);
     const metadata = descriptor.toMetadata();
@@ -254,49 +309,6 @@ const toProcessWorkerWireLockBuffers = (lock, descriptor) => ({
     payload: toChildProcessSharedBufferMetadata(lock.payload, descriptor),
     payloadSector: toChildProcessSharedBufferMetadata(lock.payloadSector, descriptor),
 });
-const isPlainRecord = (value) => {
-    if (value === null || typeof value !== "object")
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-};
-const serializeWorkerBootstrapValue = (value, seen = new WeakMap()) => {
-    if (value instanceof ProcessSharedBuffer)
-        return value.toMetadata();
-    if (value === null || typeof value !== "object")
-        return value;
-    const existing = seen.get(value);
-    if (existing !== undefined)
-        return existing;
-    if (Array.isArray(value)) {
-        const out = [];
-        seen.set(value, out);
-        for (const item of value) {
-            out.push(serializeWorkerBootstrapValue(item, seen));
-        }
-        return out;
-    }
-    if (!isPlainRecord(value))
-        return value;
-    const out = {};
-    seen.set(value, out);
-    for (const [key, item] of Object.entries(value)) {
-        out[key] = serializeWorkerBootstrapValue(item, seen);
-    }
-    return out;
-};
-export const serializeWorkerBootstrapData = (options) => {
-    const bootstrap = options.bootstrap;
-    if (bootstrap === undefined || bootstrap.data === undefined)
-        return options;
-    return {
-        ...options,
-        bootstrap: {
-            ...bootstrap,
-            data: serializeWorkerBootstrapValue(bootstrap.data),
-        },
-    };
-};
 export const toProcessWorkerBootPayload = (workerData, memory) => ({
     version: RUNTIME_PROCESS_WORKER_BOOT_VERSION,
     workerData: {
@@ -417,10 +429,62 @@ const processWorkerNodeBinary = (commandPrefix) => {
             : undefined) ??
         DEFAULT_NODE_BINARY;
 };
-const processWorkerNodeExecArgv = (permission) => {
+const processWorkerNodeMajorCache = new Map();
+const resolveProcessWorkerNodeMajor = (commandPrefix) => {
+    const nodeProcess = getNodeProcess();
+    if (commandPrefix === undefined &&
+        nodeProcess !== undefined &&
+        nodeProcess?.env?.NODE_BINARY === undefined &&
+        RUNTIME === "node") {
+        return parseNodeMajorVersion(nodeProcess.versions?.node);
+    }
+    const nodeBinary = processWorkerNodeBinary(commandPrefix);
+    const cacheKey = JSON.stringify([commandPrefix ?? null, nodeBinary]);
+    if (processWorkerNodeMajorCache.has(cacheKey)) {
+        return processWorkerNodeMajorCache.get(cacheKey);
+    }
+    let major;
+    try {
+        const childProcess = getNodeBuiltinModule("node:child_process");
+        if (typeof childProcess?.spawnSync === "function") {
+            const command = commandPrefix?.[0] ?? nodeBinary;
+            const args = commandPrefix === undefined
+                ? ["--version"]
+                : [...commandPrefix.slice(1), nodeBinary, "--version"];
+            const probe = childProcess.spawnSync(command, args, {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 2_000,
+                windowsHide: true,
+            });
+            if (probe.status === 0) {
+                major = parseNodeMajorVersion(probe.stdout);
+            }
+        }
+    }
+    catch {
+        // Unknown targets conservatively use the Node 22/24 addon transport.
+    }
+    processWorkerNodeMajorCache.set(cacheKey, major);
+    return major;
+};
+export const readProcessWorkerNodeMajor = (options) => resolveProcessWorkerNodeMajor(readProcessWorkerCommandPrefix(options));
+const nodeProcessWorkerFlagIsSupported = (flag, nodeMajor) => {
+    const key = flag.split("=", 1)[0];
+    if (key === "--experimental-ffi" || key === "--allow-ffi") {
+        return nodeProcessWorkerUsesFfi(nodeMajor);
+    }
+    if (key === "--allow-net") {
+        return nodeMajor !== undefined && nodeMajor >= 25;
+    }
+    return true;
+};
+const processWorkerNodeExecArgv = (permission, nodeMajor) => {
     const out = [];
     const seen = new Set();
     const add = (flag) => {
+        if (!nodeProcessWorkerFlagIsSupported(flag, nodeMajor))
+            return;
         if (seen.has(flag))
             return;
         seen.add(flag);
@@ -429,16 +493,17 @@ const processWorkerNodeExecArgv = (permission) => {
     for (const flag of toWorkerCompatExecArgv(getNodeProcess()?.execArgv) ?? []) {
         add(flag);
     }
-    for (const flag of nodeProcessWorkerInternalExecArgv())
+    for (const flag of nodeProcessWorkerInternalExecArgv(nodeMajor))
         add(flag);
     if (permission?.enabled === true && permission.unsafe !== true) {
         for (const flag of permission.node.flags)
             add(flag);
-        if (permission.netAll && nodeMajorVersion() >= 25)
+        if (permission.netAll && nodeMajor !== undefined && nodeMajor >= 25) {
             add("--allow-net");
+        }
         // Node process workers need one native transport capability regardless of
         // task permissions: addons on Node 22/24, node:ffi on supported Node 26+ LTS.
-        add(nodeProcessWorkerUsesFfi() ? "--allow-ffi" : "--allow-addons");
+        add(nodeProcessWorkerUsesFfi(nodeMajor) ? "--allow-ffi" : "--allow-addons");
     }
     return out;
 };
@@ -454,9 +519,10 @@ const processWorkerCommand = ({ processRuntime, workerUrl, bun, deno, commandPre
         ];
     }
     else if (processRuntime === "node") {
+        const nodeMajor = resolveProcessWorkerNodeMajor(commandPrefix);
         command = [
             processWorkerNodeBinary(commandPrefix),
-            ...processWorkerNodeExecArgv(permission),
+            ...processWorkerNodeExecArgv(permission, nodeMajor),
             workerPath,
         ];
     }
@@ -596,9 +662,23 @@ const spawnNodeHostedProcessWorker = ({ workerUrl, bootPayload, memory, processR
         queueMicrotask(() => child.send?.(bootPayload));
     }
     child.on("error", events.emitError);
-    child.on("exit", (code) => events.emitExit(code ?? -1));
+    let resolveExit = () => { };
+    const exited = new Promise((resolve) => {
+        resolveExit = resolve;
+    });
+    child.on("exit", (code) => {
+        resolveExit();
+        events.emitExit(code ?? -1);
+    });
     return {
-        terminate: () => child.kill(),
+        terminate: () => {
+            try {
+                child.kill();
+            }
+            catch {
+            }
+            return exited;
+        },
         unref: () => child.unref?.(),
         on: events.on,
     };
@@ -687,16 +767,6 @@ export const spawnProcessWorker = (options) => {
             throw new Error("process worker runtime is only available in Node, Deno, or Bun");
     }
 };
-export const terminateWorkerQuietly = (worker) => {
-    try {
-        // Runaway worker termination can be slow or stuck on some runtimes; once the
-        // pool is closing it must not keep the host process alive.
-        worker.unref?.();
-        void Promise.resolve(worker.terminate()).catch(() => { });
-    }
-    catch {
-    }
-};
 export const cleanupProcessWorkerMemoryQuietly = (memory) => {
     try {
         memory?.cleanup();

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

@@ -11,15 +11,31 @@ type CreateHostTxQueueArgs = {
     max?: number;
     lock: Lock2;
     returnLock: Lock2;
+    /**
+     * Extra return locks to drain into the same pending registry.
+     *
+     * Under work stealing the host publishes into one shared submit lock and any
+     * worker may claim the task, so the response comes back on whichever lane
+     * executed it. Task IDs index this queue's `queue` array, which is
+     * pool-global, so every lane's `resolveHost` can settle into it — the
+     * stealing worker owns the response and the host demultiplexes by ID.
+     *
+     * 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;
 };
-export declare function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenceReturn, abortSignals, now, }: CreateHostTxQueueArgs): {
+type ReturnHooks = ((token: bigint) => void) | BufferReferenceReturnHooks;
+export declare function createHostTxQueue({ max, lock, returnLock, extraReturnLocks, releaseBufferReferenceReturn, abortSignals, now, }: CreateHostTxQueueArgs): {
     rejectAll: (reason: string) => void;
     hasPendingFrames: () => boolean;
     txIdle: () => boolean;
     completeFrame: () => number;
+    waitForCompletion: (onWake: () => void, timeoutMs?: number) => 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;

package/src/runtime/tx-queue.js

@@ -14,7 +14,7 @@ const FUNCTION_META_SHIFT = 16;
 const ABORT_SIGNAL_META_OFFSET = 1;
 const NO_ABORT_SIGNAL = -1;
 const p_now = performance.now.bind(performance);
-export function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenceReturn, abortSignals, now, }) {
+export function createHostTxQueue({ max, lock, returnLock, extraReturnLocks, releaseBufferReferenceReturn, abortSignals, now, }) {
     const PLACE_HOLDER = (_) => {
         throw ("UNREACHABLE FROM PLACE HOLDER (main)");
     };
@@ -37,22 +37,119 @@ export function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenc
     let inUsed = 0 | 0;
     const resetSignal = abortSignals?.resetSignal;
     const nowTime = now ?? p_now;
-    const resolveReturn = returnLock.resolveHost({
+    const onReturnResolved = (task) => {
+        inUsed = (inUsed - 1) | 0;
+        resetTaskLocalFlags(task);
+        runTaskFinalizers(task);
+        task.value = null;
+        task.resolve = PLACE_HOLDER;
+        task.reject = PLACE_HOLDER;
+        freePush(task[TaskIndex.ID]);
+    };
+    const returnResolvers = [
+        returnLock,
+        ...(extraReturnLocks ?? []),
+    ].map((each) => each.resolveHost({
         queue,
         activeRejectPlaceholder: PLACE_HOLDER,
-        onResolved: (task) => {
-            inUsed = (inUsed - 1) | 0;
-            resetTaskLocalFlags(task);
-            runTaskFinalizers(task);
-            task.value = null;
-            task.resolve = PLACE_HOLDER;
-            task.reject = PLACE_HOLDER;
-            freePush(task[TaskIndex.ID]);
-        },
-    });
-    const completeFrame = releaseBufferReferenceReturn === undefined
-        ? resolveReturn
-        : () => withBufferReferenceReturnReleaser(releaseBufferReferenceReturn, resolveReturn);
+        onResolved: onReturnResolved,
+    }));
+    const returnWaiters = [
+        returnLock,
+        ...(extraReturnLocks ?? []),
+    ].map((each) => typeof each.waitForHostChange === "function"
+        ? each.waitForHostChange
+        : () => undefined);
+    const returnArmers = [
+        returnLock,
+        ...(extraReturnLocks ?? []),
+    ].map((each) => typeof each.setHostWaiterArmed === "function"
+        ? each.setHostWaiterArmed
+        : (_armed) => { });
+    // A stealing queue drains one private return lock per worker. Borrowed
+    // BufferReferences must therefore be claimed with the hooks belonging to the
+    // worker that produced that particular return. The hooks are bound after the
+    // worker context exists, while the pool-global queue is built before workers
+    // spawn, so keep one mutable hook slot per return lane.
+    const returnHooks = new Array(returnResolvers.length);
+    if (releaseBufferReferenceReturn !== undefined) {
+        returnHooks[0] = releaseBufferReferenceReturn;
+    }
+    const resolveReturnAt = (index) => {
+        const resolve = returnResolvers[index];
+        const hooks = returnHooks[index];
+        return hooks === undefined
+            ? resolve()
+            : withBufferReferenceReturnReleaser(hooks, resolve);
+    };
+    // Preserve the original one-lane fast path exactly: no wrapper, array lookup,
+    // or hook branch is paid by the default one-worker transport. Mutable
+    // per-return-lane hooks are needed only by a multi-worker stealing queue.
+    const completeFrame = returnResolvers.length === 1
+        ? releaseBufferReferenceReturn === undefined
+            ? returnResolvers[0]
+            : () => withBufferReferenceReturnReleaser(releaseBufferReferenceReturn, returnResolvers[0])
+        : () => {
+            let resolved = 0 | 0;
+            for (let i = 0; i < returnResolvers.length; i++) {
+                resolved = (resolved + resolveReturnAt(i)) | 0;
+            }
+            return resolved;
+        };
+    // A stealing queue has one private return lock per worker. Keep at most one
+    // waitAsync waiter per lane: after lane A rings, lane B's unresolved waiter
+    // must survive the next arm or Atomics.notify(..., 1) could wake an obsolete
+    // waiter and starve the live one until the watchdog timeout.
+    const completionArmed = new Uint8Array(returnWaiters.length);
+    let completionWake;
+    let completionGeneration = 0 | 0;
+    const setCompletionWaiterArmed = (armed) => {
+        for (const setArmed of returnArmers)
+            setArmed(armed);
+    };
+    const waitForCompletion = (onWake, timeoutMs) => {
+        completionWake = onWake;
+        // A persistent waiter may still be pending after a send preempted the
+        // dispatcher. Re-arm its shared gate before relying on that waiter again.
+        setCompletionWaiterArmed(true);
+        let supported = true;
+        for (let index = 0; index < returnWaiters.length; index++) {
+            if (completionArmed[index] !== 0)
+                continue;
+            let wait;
+            try {
+                wait = returnWaiters[index](timeoutMs);
+            }
+            catch {
+                wait = undefined;
+            }
+            if (wait === undefined) {
+                supported = false;
+                break;
+            }
+            completionArmed[index] = 1;
+            const generation = completionGeneration;
+            const wakeLane = () => {
+                if (completionArmed[index] === 0)
+                    return;
+                completionArmed[index] = 0;
+                returnArmers[index](false);
+                if (generation !== completionGeneration)
+                    return;
+                completionWake?.();
+            };
+            if (!wait.async)
+                wakeLane();
+            else
+                Promise.resolve(wait.value).then(wakeLane, wakeLane);
+        }
+        if (!supported) {
+            completionWake = undefined;
+            setCompletionWaiterArmed(false);
+            completionGeneration = (completionGeneration + 1) | 0;
+        }
+        return supported;
+    };
     const hasActiveTasks = () => {
         const count = (inUsed - getPendingPromiseCount()) | 0;
         return count > 0;
@@ -85,6 +182,14 @@ export function createHostTxQueue({ max, lock, returnLock, releaseBufferReferenc
         hasPendingFrames,
         txIdle,
         completeFrame,
+        waitForCompletion,
+        setCompletionWaiterArmed,
+        setReturnHooks: (lane, hooks) => {
+            if (!Number.isInteger(lane) || lane < 0 || lane >= returnHooks.length) {
+                throw new RangeError(`return lane ${lane} out of range`);
+            }
+            returnHooks[lane] = hooks;
+        },
         enqueue: (functionID, timeout, abortSignal) => {
             const HAS_TIMER = timeout !== undefined;
             const functionIDMasked = functionID & FUNCTION_ID_MASK;

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

@@ -0,0 +1,13 @@
+import type { WorkerSettings } from "../types.js";
+export type SpawnedWorker = {
+    terminate: () => unknown;
+    unref?: () => unknown;
+    postMessage?: (message: unknown) => void;
+};
+export type NodeWorkerLike = {
+    on?: (event: "error" | "exit" | "message", listener: (...args: unknown[]) => void) => void;
+};
+export declare const toWorkerSafeExecArgv: (flags: string[] | undefined) => string[] | undefined;
+export declare const toWorkerCompatExecArgv: (flags: string[] | undefined) => string[] | undefined;
+export declare const serializeWorkerBootstrapData: (options: WorkerSettings) => WorkerSettings;
+export declare const terminateWorkerQuietly: (worker: SpawnedWorker) => Promise<void>;