knitting 0.1.56 → 0.1.61

package/src/runtime/pool.js

@@ -1,22 +1,36 @@
 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, 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";
+// Side-effect import: registers the payload codec (cycle break for Andromeda;
+// 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, } 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";
 import { createLockControlCarpet } from "../memory/byte-carpet.js";
 import { resolvePayloadBufferOptions, } from "../memory/payload-config.js";
-import { createBufferReferenceReturnReleaseMessage } from "../connections/buffer-reference.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";
 // 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)
@@ -34,7 +48,121 @@ 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, }) => {
+    const payloadConfig = resolvePayloadBufferOptions({ options: payload });
+    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 submitCarpet = carpet();
+    const submitBuffers = toBuffers(submitCarpet.lock, makePayload());
+    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,
+    });
+    const returnBuffers = [];
+    const hostReturnLocks = [];
+    for (let i = 0; i < threads; i++) {
+        const buffers = toBuffers(carpet().returnLock, makePayload());
+        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,
+        }));
+    }
+    // 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 resolvedAbortSignalCapacity = resolveAbortSignalCapacity(abortSignalCapacity);
+    const abortSignalSAB = usesAbortSignal === true
+        ? 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,
+        abortSignalSAB,
+        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,
+            names,
+            workerOptions,
+            hostDebug,
+            abortSignalCapacity,
+            usesAbortSignal,
+        });
+    }
     const tsFileUrl = new URL(import.meta.url);
     const poliWorker = RUNTIME_WORKER;
     const resolvedWorkerOptions = serializeWorkerBootstrapData(withDefaultWorkerTimers(workerOptions));
@@ -51,32 +179,32 @@ 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 abortBytes = stealPool === undefined && usesAbortSignal === true
+        ? abortSignalByteLength(resolvedAbortSignalCapacity)
+        : 0;
     const processWorkerMemory = useProcessWorkerRuntime
         ? createProcessWorkerMemoryLayout({
             signalBytes,
@@ -118,7 +246,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({
@@ -128,7 +256,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({
@@ -136,7 +264,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,
@@ -144,8 +272,9 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         payloadSector: lockBuffers.payloadSector,
         payloadConfig: resolvedPayloadConfig,
         textCompat: lockBuffers.textCompat,
+        processBoundary: useProcessWorkerRuntime,
     });
-    const returnLock = lock2({
+    const returnLock = stealPool?.hostReturnLock ?? lock2({
         headers: returnLockBuffers.headers,
         headerSlotStrideU32: returnLockBuffers.headerSlotStrideU32,
         LockBoundSector: returnLockBuffers.lockSector,
@@ -153,11 +282,11 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         payloadSector: returnLockBuffers.payloadSector,
         payloadConfig: resolvedPayloadConfig,
         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,
@@ -178,16 +307,68 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         processRuntime: processWorkerRuntime,
         signal: signalBox.opView,
     });
-    const queue = createHostTxQueue({
+    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: bufferReferenceReturn === "borrow"
-            ? (token) => {
-                worker?.postMessage?.(createBufferReferenceReturnReleaseMessage(token));
-            }
-            : 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;
@@ -207,16 +388,21 @@ 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,
+        });
+    if (ownsChannel && dispatcherCheck !== undefined) {
         ownChannel.open(dispatcherCheck);
         channelHandler = ownChannel;
         dispatchSend = () => {
@@ -240,9 +426,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,
@@ -257,6 +442,11 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         payloadConfig: resolvedPayloadConfig,
         bufferReferenceReturn,
         permission,
+        steal: stealPool === undefined ? undefined : {
+            consumers: stealPool.consumers,
+            consumerId: stealPool.consumerId,
+            regionLanes: stealPool.regionLanes,
+        },
     };
     const baseWorkerOptions = {
         //@ts-ignore Reason
@@ -325,29 +515,51 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         worker.postMessage?.(workerDataPayload);
     }
     let closedReason;
-    const markWorkerClosed = (reason) => {
+    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.
+    const markWorkerClosed = (reason, workerBytesReadable = false) => {
         if (closedReason)
             return;
         closedReason = reason;
+        revokeOutstandingBorrowedReturns(workerBytesReadable);
         rejectAll(reason);
         channelHandler?.close();
     };
     const onWorkerMessage = (message) => {
         if (!isWorkerFatalMessage(message))
             return;
-        markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`);
-        terminateWorkerQuietly(worker);
+        markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`, true);
+        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}`);
@@ -388,15 +600,17 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         txIdle,
         call,
         kills: async () => {
-            markWorkerClosed("Thread closed");
+            markWorkerClosed("Thread closed", true);
             terminateWorkerQuietly(worker);
             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,7 +29,7 @@ export type ProcessWorkerMemoryLayout = {
     returnPayload: SharedBufferSource;
     cleanup: () => void;
 };
-export type ProcessWorkerRuntime = NonNullable<WorkerSettings["processRuntime"]>;
+export type ProcessWorkerRuntime = "bun" | "deno" | "node";
 export type ProcessWorkerCommandPrefix = NonNullable<WorkerSettings["processCommandPrefix"]>;
 export type ResolvedProcessSharedMemorySettings = {
     mode: "inherit" | "named";
@@ -60,8 +53,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 +61,11 @@ export declare const createProcessWorkerMemoryLayout: ({ signalBytes, abortBytes
     thread: number;
     sharedMemory: ResolvedProcessSharedMemorySettings;
 }) => ProcessWorkerMemoryLayout;
-export declare const serializeWorkerBootstrapData: (options: WorkerSettings) => WorkerSettings;
 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 +78,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 {};