knitting 0.1.60 → 0.1.62

package/src/runtime/pool.js

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

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

@@ -1,17 +1,10 @@
 import { type LockControlCarpet } from "../memory/byte-carpet.js";
 import type { DebugOptions, LockBuffers, WorkerData, WorkerSettings } from "../types.js";
+import { type NodeWorkerLike, type SpawnedWorker } from "./worker-common.js";
 import { RUNTIME_PROCESS_WORKER_BOOT_VERSION } from "../common/worker-runtime.js";
 import { type SharedBufferSource } from "../common/shared-buffer-region.js";
 import { FileDescriptor, type ProcessSharedBufferMetadata } from "../connections/index.js";
 import type { SharedMemoryBuffer, SharedMemoryMapping } from "../connections/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;
-};
 type ProcessWorkerWireLockBuffers = Omit<LockBuffers, "headers" | "lockSector" | "payload" | "payloadSector"> & {
     headers: ProcessSharedBufferMetadata;
     lockSector: ProcessSharedBufferMetadata;
@@ -36,6 +29,20 @@ export type ProcessWorkerMemoryLayout = {
     returnPayload: SharedBufferSource;
     cleanup: () => void;
 };
+/**
+ * Process-worker memory for a stealing pool.
+ *
+ * The request side is one shared region all child processes may claim from;
+ * each worker keeps its own signals and return region. Every per-worker view
+ * points into the same OS mapping so the existing fd/name boot protocol can
+ * carry all of the slices without adding a second descriptor to WorkerData.
+ */
+export type ProcessStealMemoryLayout = {
+    mapping: SharedMemoryMapping<SharedMemoryBuffer>;
+    descriptor: FileDescriptor;
+    workers: ProcessWorkerMemoryLayout[];
+    abortSignalMax?: number;
+};
 export type ProcessWorkerRuntime = "bun" | "deno" | "node";
 export type ProcessWorkerCommandPrefix = NonNullable<WorkerSettings["processCommandPrefix"]>;
 export type ResolvedProcessSharedMemorySettings = {
@@ -60,8 +67,6 @@ type ProcessSharedMemoryAllocator = {
     createBuffer: (byteLength: number) => SharedArrayBuffer;
     backings: ProcessSharedMemoryBacking[];
 };
-export declare const toWorkerSafeExecArgv: (flags: string[] | undefined) => string[] | undefined;
-export declare const toWorkerCompatExecArgv: (flags: string[] | undefined) => string[] | undefined;
 export declare const createProcessSharedMemoryAllocator: (debug: DebugOptions | undefined) => ProcessSharedMemoryAllocator | undefined;
 export declare const createProcessWorkerMemoryLayout: ({ signalBytes, abortBytes, payloadBytes, thread, sharedMemory, }: {
     signalBytes: number;
@@ -70,11 +75,19 @@ export declare const createProcessWorkerMemoryLayout: ({ signalBytes, abortBytes
     thread: number;
     sharedMemory: ResolvedProcessSharedMemorySettings;
 }) => ProcessWorkerMemoryLayout;
-export declare const serializeWorkerBootstrapData: (options: WorkerSettings) => WorkerSettings;
+export declare const createProcessStealMemoryLayout: ({ threads, signalBytes, abortBytes, abortSignalMax, payloadBytes, sharedMemory, }: {
+    threads: number;
+    signalBytes: number;
+    abortBytes: number;
+    abortSignalMax?: number;
+    payloadBytes: number;
+    sharedMemory: ResolvedProcessSharedMemorySettings;
+}) => ProcessStealMemoryLayout;
 export declare const toProcessWorkerBootPayload: (workerData: WorkerData, memory: ProcessWorkerMemoryLayout) => ProcessWorkerBootPayload;
 export declare const readProcessWorkerRuntime: (options: WorkerSettings | undefined) => ProcessWorkerRuntime;
 export declare const readProcessWorkerCommandPrefix: (options: WorkerSettings | undefined) => ProcessWorkerCommandPrefix | undefined;
 export declare const readProcessSharedMemorySettings: (options: WorkerSettings | undefined) => ResolvedProcessSharedMemorySettings;
+export declare const readProcessWorkerNodeMajor: (options: WorkerSettings | undefined) => number | undefined;
 export declare const createProcessWorkerNativeSignalNotifier: ({ processRuntime, signal, }: {
     processRuntime: ProcessWorkerRuntime | undefined;
     signal: Int32Array;
@@ -87,6 +100,5 @@ export declare const spawnProcessWorker: (options: {
     commandPrefix?: ProcessWorkerCommandPrefix;
     permission?: WorkerData["permission"];
 }) => SpawnedWorker & NodeWorkerLike;
-export declare const terminateWorkerQuietly: (worker: SpawnedWorker) => void;
 export declare const cleanupProcessWorkerMemoryQuietly: (memory: ProcessWorkerMemoryLayout | undefined) => void;
 export {};