knitting 0.1.46 → 0.1.50

package/src/runtime/pool.js

@@ -1,70 +1,19 @@
-// main.ts
-import { fileURLToPath as fileURLToPathCompat } from "node:url";
 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 { 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";
 import "../worker/loop.js";
-import { createSharedArrayBuffer, createWasmSharedArrayBuffer, RUNTIME, } from "../common/runtime.js";
-import { HAS_NODE_WORKER_THREADS, RUNTIME_PROCESS_WORKER_BOOT_ENV, RUNTIME_PROCESS_WORKER_BOOT_VERSION, RUNTIME_PROCESS_WORKER_ENV, RUNTIME_WORKER, } from "../common/worker-runtime.js";
-import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
+import { createSharedArrayBuffer, createWasmSharedArrayBuffer, } 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 { createByteCarpet, createLockControlCarpet, getHeaderBlockByteLength, makeSharedBufferRegion, } from "../memory/byte-carpet.js";
+import { createLockControlCarpet } from "../memory/byte-carpet.js";
 import { resolvePayloadBufferOptions, } from "../memory/payload-config.js";
-import { getNodeBuiltinModule, getNodeProcess, } from "../common/node-compat.js";
-import { createBunConnectionPrimitives } from "../connections/bun.js";
-import { createDenoConnectionPrimitives } from "../connections/deno.js";
-import { FileDescriptor, ProcessSharedBuffer, } from "../connections/index.js";
-import { createNodeConnectionPrimitives, loadNodeFutexAddon, } from "../connections/node.js";
-import { loadNodeNativeAddon } from "../connections/node-addons.js";
-import { assertPosixSharedMemoryPlatform, detectPosixPlatform, } from "../connections/posix.js";
 const WORKER_FATAL_MESSAGE_KEY = "__knittingWorkerFatal";
-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-addons",
-    "--allow-wasi",
-]);
-const NODE_WORKER_SAFE_EXEC_FLAGS = new Set([
-    "--experimental-transform-types",
-    "--expose-gc",
-    "--no-warnings",
-    ...NODE_PERMISSION_EXEC_FLAGS,
-]);
 const isWorkerFatalMessage = (value) => !!value &&
     typeof value === "object" &&
     typeof value[WORKER_FATAL_MESSAGE_KEY] === "string";
-const isNodeWorkerSafeExecFlag = (flag) => NODE_WORKER_SAFE_EXEC_FLAGS.has(execFlagKey(flag));
-const isNodePermissionExecFlag = (flag) => NODE_PERMISSION_EXEC_FLAGS.has(execFlagKey(flag));
-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;
-};
-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;
-};
 // Keep idle workers self-healing if an Atomics.notify wake is missed.
 const DEFAULT_WORKER_PARK_MS = 1;
 const withDefaultWorkerTimers = (options) => {
@@ -79,508 +28,25 @@ const withDefaultWorkerTimers = (options) => {
         },
     };
 };
-const toProcessSharedMemorySize = (byteLength) => {
-    if (!Number.isFinite(byteLength) || byteLength <= 0) {
-        throw new RangeError("process shared memory byteLength must be positive");
-    }
-    const size = Math.trunc(byteLength);
-    return size + ((64 - (size % 64)) % 64);
-};
-const createProcessSharedMemoryAllocator = (debug) => {
-    if (RUNTIME !== "node")
-        return undefined;
-    try {
-        assertPosixSharedMemoryPlatform("Process-shared memory allocator");
-    }
-    catch {
-        return undefined;
-    }
-    let addon;
-    try {
-        const nodeModule = getNodeBuiltinModule("node:module");
-        if (nodeModule === undefined)
-            return undefined;
-        const require = nodeModule.createRequire(import.meta.url);
-        addon = loadNodeNativeAddon(require, "knitting_shared_memory");
-    }
-    catch (error) {
-        if (debug?.extras === true) {
-            console.warn("Process-shared memory allocator unavailable; falling back to SharedArrayBuffer.", error);
-        }
-        return undefined;
-    }
-    const backings = [];
-    return {
-        backings,
-        createBuffer: (byteLength) => {
-            const mapping = addon.createSharedMemory(toProcessSharedMemorySize(byteLength));
-            backings.push({
-                ...mapping,
-                runtime: "node",
-                buffer: mapping.sab,
-                kind: "shared-array-buffer",
-                byteLength: mapping.sab.byteLength,
-            });
-            return mapping.sab;
-        },
-    };
-};
-const PROCESS_WORKER_CHILD_FD = 0;
-const DEFAULT_BUN_BINARY = "bun";
-const DEFAULT_DENO_BINARY = "deno";
-const DEFAULT_NODE_BINARY = "node";
-const DENO_PROCESS_WORKER_BOOT_ENV_ALLOW = [
-    RUNTIME_PROCESS_WORKER_ENV,
-    RUNTIME_PROCESS_WORKER_BOOT_ENV,
-].join(",");
-const DENO_PROCESS_WORKER_INTERNAL_FLAGS = [
-    `--allow-env=${DENO_PROCESS_WORKER_BOOT_ENV_ALLOW}`,
-    "--allow-ffi",
-];
-const NODE_PROCESS_WORKER_EXEC_ARGV = [
-    "--no-warnings",
-    "--experimental-transform-types",
-];
 const withFixedPayloadConfig = (config) => ({
     ...config,
     mode: "fixed",
     payloadInitialBytes: config.payloadMaxByteLength,
 });
-const getProcessWorkerSharedMemoryPrimitives = () => {
-    assertPosixSharedMemoryPlatform("Process worker runtime");
-    switch (RUNTIME) {
-        case "bun":
-            return createBunConnectionPrimitives();
-        case "deno":
-            return createDenoConnectionPrimitives();
-        case "node":
-            return createNodeConnectionPrimitives();
-        default:
-            throw new Error("process worker runtime needs Node, Deno, or Bun shared memory primitives");
-    }
-};
-const createProcessWorkerMemoryLayout = ({ signalBytes, abortBytes, payloadBytes, thread, }) => {
-    const carpet = createByteCarpet();
-    const signalsSlice = carpet.take("signals", signalBytes);
-    const requestLockSlice = carpet.take("requestLockSector", LOCK_SECTOR_BYTE_LENGTH);
-    const returnLockSlice = carpet.take("returnLockSector", LOCK_SECTOR_BYTE_LENGTH);
-    const requestHeadersSlice = carpet.take("requestHeaders", getHeaderBlockByteLength({
-        slotCount: LockBound.slots,
-        slotStrideU32: HEADER_SLOT_STRIDE_U32,
-        alignTo: 64,
-    }));
-    const returnHeadersSlice = carpet.take("returnHeaders", getHeaderBlockByteLength({
-        slotCount: LockBound.slots,
-        slotStrideU32: HEADER_SLOT_STRIDE_U32,
-        alignTo: 64,
-    }));
-    const abortSignalsSlice = carpet.take("abortSignals", abortBytes);
-    const requestPayloadSlice = carpet.take("requestPayload", payloadBytes);
-    const returnPayloadSlice = carpet.take("returnPayload", payloadBytes);
-    const primitives = getProcessWorkerSharedMemoryPrimitives();
-    const mapping = primitives.createSharedMemory({
-        size: carpet.byteLength(),
-        name: `knitting_process_worker_${thread}`,
-    });
-    const buffer = mapping.buffer;
-    const bind = (slice) => makeSharedBufferRegion(buffer, slice.byteOffset, slice.byteLength);
-    const controlLayout = {
-        controlSAB: buffer,
-        signals: bind(signalsSlice),
-        abortSignals: bind(abortSignalsSlice),
-        lock: {
-            headers: bind(requestHeadersSlice),
-            headerSlotStrideU32: HEADER_SLOT_STRIDE_U32,
-            lockSector: bind(requestLockSlice),
-            payloadSector: bind(requestLockSlice),
-        },
-        returnLock: {
-            headers: bind(returnHeadersSlice),
-            headerSlotStrideU32: HEADER_SLOT_STRIDE_U32,
-            lockSector: bind(returnLockSlice),
-            payloadSector: bind(returnLockSlice),
-        },
-        slices: carpet.slices,
-    };
-    return {
-        mapping,
-        descriptor: FileDescriptor.fromMapping(mapping),
-        controlLayout,
-        lockPayload: bind(requestPayloadSlice),
-        returnPayload: bind(returnPayloadSlice),
-    };
-};
-const toChildProcessSharedBufferMetadata = (source, descriptor) => {
-    const region = toSharedBufferRegion(source);
-    return ProcessSharedBuffer.fromDescriptor(new FileDescriptor({
-        ...descriptor.toMetadata(),
-        fd: PROCESS_WORKER_CHILD_FD,
-    }), {
-        byteOffset: region.byteOffset,
-        byteLength: region.byteLength,
-    }).toMetadata();
-};
-const toProcessWorkerWireLockBuffers = (lock, descriptor) => ({
-    ...lock,
-    headers: toChildProcessSharedBufferMetadata(lock.headers, descriptor),
-    lockSector: toChildProcessSharedBufferMetadata(lock.lockSector, descriptor),
-    payload: toChildProcessSharedBufferMetadata(lock.payload, descriptor),
-    payloadSector: toChildProcessSharedBufferMetadata(lock.payloadSector, descriptor),
-});
-const toProcessWorkerBootPayload = (workerData, memory) => ({
-    version: RUNTIME_PROCESS_WORKER_BOOT_VERSION,
-    workerData: {
-        ...workerData,
-        sab: toChildProcessSharedBufferMetadata(workerData.sab, memory.descriptor),
-        abortSignalSAB: workerData.abortSignalSAB === undefined
-            ? undefined
-            : toChildProcessSharedBufferMetadata(workerData.abortSignalSAB, memory.descriptor),
-        lock: toProcessWorkerWireLockBuffers(workerData.lock, memory.descriptor),
-        returnLock: toProcessWorkerWireLockBuffers(workerData.returnLock, memory.descriptor),
-    },
-});
-const toProcessWorkerPath = (specifier) => {
-    const value = specifier instanceof URL ? specifier.href : specifier;
-    if (value.startsWith("file:"))
-        return fileURLToPathCompat(value);
-    return value;
-};
-const readProcessWorkerRuntime = (options) => {
-    const runtime = options?.processRuntime ?? "bun";
-    if (runtime === "bun" || runtime === "deno" || runtime === "node") {
-        return runtime;
-    }
-    throw new TypeError(`Unsupported process worker runtime: ${String(runtime)}`);
-};
-const readProcessWorkerCommandPrefix = (options) => {
-    const prefix = options?.processCommandPrefix;
-    if (prefix === undefined)
-        return undefined;
-    if (!Array.isArray(prefix)) {
-        throw new TypeError("processCommandPrefix must be an argv array");
-    }
-    if (prefix.length === 0)
-        return undefined;
-    const out = [];
-    for (const [index, value] of prefix.entries()) {
-        if (typeof value !== "string" || value.length === 0) {
-            throw new TypeError(`processCommandPrefix[${index}] must be a non-empty string`);
-        }
-        out.push(value);
-    }
-    return out;
-};
-const currentProcessEnv = () => ({
-    ...getNodeProcess()?.env,
-});
-const processWorkerEnv = (extra) => ({
-    ...currentProcessEnv(),
-    [RUNTIME_PROCESS_WORKER_ENV]: "1",
-    ...extra,
-});
-const processWorkerBootEnv = (bootPayload) => processWorkerEnv({
-    [RUNTIME_PROCESS_WORKER_BOOT_ENV]: JSON.stringify(bootPayload),
-});
-const stringProcessEnv = (input) => {
-    const out = {};
-    for (const [key, value] of Object.entries(input)) {
-        if (value !== undefined)
-            out[key] = value;
-    }
-    return out;
-};
-const processWorkerBunBinary = (bun) => getNodeProcess()?.env?.BUN_BINARY ??
-    bun?.argv?.[0] ??
-    DEFAULT_BUN_BINARY;
-const processWorkerDenoBinary = (deno) => getNodeProcess()?.env?.DENO_BINARY ??
-    deno?.execPath?.() ??
-    DEFAULT_DENO_BINARY;
-const processWorkerDenoFlags = (permission) => {
-    if (permission?.enabled !== true || permission.unsafe === true) {
-        return ["-A"];
-    }
-    return [
-        ...DENO_PROCESS_WORKER_INTERNAL_FLAGS,
-        ...permission.deno.flags,
-    ];
-};
-const processWorkerNodeBinary = () => {
-    const nodeProcess = getNodeProcess();
-    return nodeProcess?.env?.NODE_BINARY ??
-        (RUNTIME === "node" ? nodeProcess?.execPath : undefined) ??
-        DEFAULT_NODE_BINARY;
-};
-const processWorkerNodeExecArgv = () => {
-    const out = [];
-    const seen = new Set();
-    const add = (flag) => {
-        if (seen.has(flag))
-            return;
-        seen.add(flag);
-        out.push(flag);
-    };
-    for (const flag of toWorkerCompatExecArgv(getNodeProcess()?.execArgv) ?? []) {
-        add(flag);
-    }
-    for (const flag of NODE_PROCESS_WORKER_EXEC_ARGV)
-        add(flag);
-    return out;
-};
-const processWorkerCommand = ({ processRuntime, workerUrl, bun, deno, commandPrefix, permission, }) => {
-    const workerPath = toProcessWorkerPath(workerUrl);
-    let command;
-    if (processRuntime === "deno") {
-        command = [
-            processWorkerDenoBinary(deno),
-            "run",
-            ...processWorkerDenoFlags(permission),
-            workerPath,
-        ];
-    }
-    else if (processRuntime === "node") {
-        command = [
-            processWorkerNodeBinary(),
-            ...processWorkerNodeExecArgv(),
-            workerPath,
-        ];
-    }
-    else {
-        command = [processWorkerBunBinary(bun), workerPath];
-    }
-    return commandPrefix === undefined
-        ? command
-        : [...commandPrefix, ...command];
-};
-const createProcessWorkerNativeSignalNotifier = ({ processRuntime, signal, }) => {
-    if (RUNTIME !== "node" || processRuntime !== "node")
-        return undefined;
-    try {
-        const futex = loadNodeFutexAddon();
-        return () => {
-            futex.wakeU32(signal.buffer, signal.byteOffset, 1);
-        };
-    }
-    catch {
-        return undefined;
-    }
-};
-const createProcessWorkerEventHub = () => {
-    const messageHandlers = [];
-    const errorHandlers = [];
-    const exitHandlers = [];
-    return {
-        emitMessage: (message) => {
-            for (const handler of messageHandlers)
-                handler(message);
-        },
-        emitError: (error) => {
-            for (const handler of errorHandlers)
-                handler(error);
-        },
-        emitExit: (code) => {
-            for (const handler of exitHandlers)
-                handler(code);
-        },
-        on: (event, listener) => {
-            if (event === "message")
-                messageHandlers.push(listener);
-            if (event === "error")
-                errorHandlers.push(listener);
-            if (event === "exit")
-                exitHandlers.push(listener);
-        },
-    };
-};
-const spawnBunHostedProcessWorker = ({ workerUrl, bootPayload, memory, processRuntime, commandPrefix, permission, }) => {
-    const bun = globalThis.Bun;
-    if (typeof bun?.spawn !== "function") {
-        throw new Error("Bun.spawn is not available for process workers");
-    }
-    const events = createProcessWorkerEventHub();
-    const nodeProcess = getNodeProcess();
-    const useIpcBoot = processRuntime === "bun" && commandPrefix === undefined;
-    const spawnOptions = {
-        cmd: processWorkerCommand({
-            processRuntime,
-            workerUrl,
-            bun,
-            commandPrefix,
-            permission,
-        }),
-        cwd: nodeProcess?.cwd?.(),
-        env: useIpcBoot
-            ? processWorkerEnv()
-            : processWorkerBootEnv(bootPayload),
-        stdin: memory.mapping.fd,
-        stdout: "inherit",
-        stderr: "inherit",
-        onExit: (_subprocess, exitCode, _signalCode, error) => {
-            if (error !== undefined)
-                events.emitError(error);
-            events.emitExit(exitCode ?? -1);
-        },
-    };
-    if (useIpcBoot) {
-        spawnOptions.serialization = "advanced";
-        spawnOptions.ipc = (message) => {
-            events.emitMessage(message);
-        };
-    }
-    const child = bun.spawn(spawnOptions);
-    if (useIpcBoot) {
-        queueMicrotask(() => child.send?.(bootPayload));
-    }
-    child.exited.catch((error) => {
-        events.emitError(error);
-    });
-    return {
-        terminate: () => {
-            child.kill();
-            return child.exited.catch(() => undefined);
-        },
-        on: events.on,
-    };
-};
-const spawnNodeHostedProcessWorker = ({ workerUrl, bootPayload, memory, processRuntime, commandPrefix, permission, }) => {
-    const childProcess = getNodeBuiltinModule("node:child_process");
-    if (typeof childProcess?.spawn !== "function") {
-        throw new Error("node:child_process.spawn is not available");
-    }
-    const events = createProcessWorkerEventHub();
-    const useIpcBoot = processRuntime === "bun" && commandPrefix === undefined;
-    const [command, ...args] = processWorkerCommand({
-        processRuntime,
-        workerUrl,
-        commandPrefix,
-        permission,
-    });
-    const child = childProcess.spawn(command, args, {
-        cwd: getNodeProcess()?.cwd?.(),
-        env: useIpcBoot
-            ? processWorkerEnv()
-            : processWorkerBootEnv(bootPayload),
-        stdio: useIpcBoot
-            ? [memory.mapping.fd, "inherit", "inherit", "ipc"]
-            : [memory.mapping.fd, "inherit", "inherit"],
-    });
-    if (useIpcBoot) {
-        child.on("message", events.emitMessage);
-        queueMicrotask(() => child.send?.(bootPayload));
-    }
-    child.on("error", events.emitError);
-    child.on("exit", (code) => events.emitExit(code ?? -1));
-    return {
-        terminate: () => child.kill(),
-        unref: () => child.unref?.(),
-        on: events.on,
-    };
-};
-const getDenoRuntime = () => globalThis.Deno;
-const denoFileRid = (file) => {
-    for (const symbol of Object.getOwnPropertySymbols(file)) {
-        if (String(symbol) === "Symbol(Deno.internal.rid)") {
-            const rid = file[symbol];
-            if (typeof rid === "number")
-                return rid;
-        }
-    }
-    throw new Error("Deno FsFile resource id is not available");
-};
-const openDenoInheritedFd = (fd) => {
-    const deno = getDenoRuntime();
-    if (typeof deno?.openSync !== "function") {
-        throw new Error("Deno.openSync is not available for process workers");
-    }
-    const fdPath = detectPosixPlatform() === "linux"
-        ? `/proc/self/fd/${fd}`
-        : `/dev/fd/${fd}`;
-    return deno.openSync(fdPath, { read: true, write: true });
-};
-const spawnDenoHostedProcessWorker = ({ workerUrl, bootPayload, memory, processRuntime, commandPrefix, permission, }) => {
-    const deno = getDenoRuntime();
-    if (typeof deno?.Command !== "function") {
-        throw new Error("Deno.Command is not available for process workers");
-    }
-    const inheritedFd = openDenoInheritedFd(memory.mapping.fd);
-    const events = createProcessWorkerEventHub();
-    const [command, ...args] = processWorkerCommand({
-        processRuntime,
-        workerUrl,
-        deno,
-        commandPrefix,
-        permission,
-    });
-    const child = new deno.Command(command, {
-        args,
-        cwd: deno.cwd?.(),
-        env: stringProcessEnv(processWorkerBootEnv(bootPayload)),
-        stdin: denoFileRid(inheritedFd),
-        stdout: "inherit",
-        stderr: "inherit",
-    }).spawn();
-    const closeInheritedFd = () => {
-        try {
-            inheritedFd.close?.();
-        }
-        catch {
-        }
-    };
-    child.status.then((status) => {
-        closeInheritedFd();
-        events.emitExit(status.code);
-    }, (error) => {
-        closeInheritedFd();
-        events.emitError(error);
-        events.emitExit(-1);
-    });
-    return {
-        terminate: () => {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch {
-            }
-            return child.status.finally(closeInheritedFd);
-        },
-        on: events.on,
-    };
-};
-const spawnProcessWorker = (options) => {
-    switch (RUNTIME) {
-        case "bun":
-            return spawnBunHostedProcessWorker(options);
-        case "node":
-            return spawnNodeHostedProcessWorker(options);
-        case "deno":
-            return spawnDenoHostedProcessWorker(options);
-        default:
-            throw new Error("process worker runtime is only available in Node, Deno, or Bun");
-    }
-};
-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 spawnWorkerContext = ({ list, ids, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }) => {
     const tsFileUrl = new URL(import.meta.url);
     const poliWorker = RUNTIME_WORKER;
-    const resolvedWorkerOptions = withDefaultWorkerTimers(workerOptions);
+    const resolvedWorkerOptions = serializeWorkerBootstrapData(withDefaultWorkerTimers(workerOptions));
     const useProcessWorkerRuntime = resolvedWorkerOptions.runtime === "process";
-    if (useProcessWorkerRuntime) {
-        assertPosixSharedMemoryPlatform("Process worker runtime");
-    }
     const processWorkerRuntime = useProcessWorkerRuntime
         ? readProcessWorkerRuntime(resolvedWorkerOptions)
         : undefined;
     const processWorkerCommandPrefix = useProcessWorkerRuntime
         ? readProcessWorkerCommandPrefix(resolvedWorkerOptions)
         : undefined;
+    const processSharedMemorySettings = useProcessWorkerRuntime
+        ? readProcessSharedMemorySettings(resolvedWorkerOptions)
+        : undefined;
     if (debug?.logHref === true) {
         console.log(tsFileUrl);
     }
@@ -627,6 +93,7 @@ export const spawnWorkerContext = ({ list, ids, sab, thread, debug, totalNumberO
             abortBytes,
             payloadBytes: resolvedPayloadConfig.payloadMaxByteLength,
             thread,
+            sharedMemory: processSharedMemorySettings,
         })
         : undefined;
     const processSharedMemory = processWorkerMemory === undefined
@@ -914,6 +381,7 @@ export const spawnWorkerContext = ({ list, ids, sab, thread, debug, totalNumberO
         kills: async () => {
             markWorkerClosed("Thread closed");
             terminateWorkerQuietly(worker);
+            cleanupProcessWorkerMemoryQuietly(processWorkerMemory);
         },
         lock,
         processSharedMemoryBackings: processSharedMemory?.backings,

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

@@ -0,0 +1,92 @@
+import { type LockControlCarpet } from "../memory/byte-carpet.js";
+import type { DebugOptions, LockBuffers, WorkerData, WorkerSettings } from "../types.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;
+    payload: ProcessSharedBufferMetadata;
+    payloadSector: ProcessSharedBufferMetadata;
+};
+type ProcessWorkerWireData = Omit<WorkerData, "sab" | "abortSignalSAB" | "lock" | "returnLock"> & {
+    sab: ProcessSharedBufferMetadata;
+    abortSignalSAB?: ProcessSharedBufferMetadata;
+    lock: ProcessWorkerWireLockBuffers;
+    returnLock: ProcessWorkerWireLockBuffers;
+};
+export type ProcessWorkerBootPayload = {
+    version: typeof RUNTIME_PROCESS_WORKER_BOOT_VERSION;
+    workerData: ProcessWorkerWireData;
+};
+export type ProcessWorkerMemoryLayout = {
+    mapping: SharedMemoryMapping<SharedMemoryBuffer>;
+    descriptor: FileDescriptor;
+    controlLayout: LockControlCarpet;
+    lockPayload: SharedBufferSource;
+    returnPayload: SharedBufferSource;
+    cleanup: () => void;
+};
+export type ProcessWorkerRuntime = NonNullable<WorkerSettings["processRuntime"]>;
+export type ProcessWorkerCommandPrefix = NonNullable<WorkerSettings["processCommandPrefix"]>;
+export type ResolvedProcessSharedMemorySettings = {
+    mode: "inherit" | "named";
+    namePrefix?: string;
+    unlinkOnShutdown: boolean;
+};
+type ProcessSharedMemoryNativeMapping = {
+    sab: SharedArrayBuffer;
+    fd: number;
+    name?: string;
+    size: number;
+    baseAddressMod64?: number;
+};
+export type ProcessSharedMemoryBacking = ProcessSharedMemoryNativeMapping & {
+    runtime: "node";
+    buffer: SharedArrayBuffer;
+    kind: "shared-array-buffer";
+    byteLength: number;
+};
+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;
+    abortBytes: number;
+    payloadBytes: number;
+    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 createProcessWorkerNativeSignalNotifier: ({ processRuntime, signal, }: {
+    processRuntime: ProcessWorkerRuntime | undefined;
+    signal: Int32Array;
+}) => (() => void) | undefined;
+export declare const spawnProcessWorker: (options: {
+    workerUrl: string | URL;
+    bootPayload: ProcessWorkerBootPayload;
+    memory: ProcessWorkerMemoryLayout;
+    processRuntime: ProcessWorkerRuntime;
+    commandPrefix?: ProcessWorkerCommandPrefix;
+    permission?: WorkerData["permission"];
+}) => SpawnedWorker & NodeWorkerLike;
+export declare const terminateWorkerQuietly: (worker: SpawnedWorker) => void;
+export declare const cleanupProcessWorkerMemoryQuietly: (memory: ProcessWorkerMemoryLayout | undefined) => void;
+export {};