knitting 0.1.46 → 0.1.50

package/src/runtime/process-worker.js

@@ -0,0 +1,670 @@
+import { fileURLToPath as fileURLToPathCompat } from "node:url";
+import { HEADER_SLOT_STRIDE_U32, LOCK_SECTOR_BYTE_LENGTH, LockBound, } from "../memory/lock.js";
+import { createByteCarpet, getHeaderBlockByteLength, makeSharedBufferRegion, } from "../memory/byte-carpet.js";
+import { RUNTIME } from "../common/runtime.js";
+import { 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";
+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 { detectPosixPlatform } from "../connections/posix.js";
+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 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");
+    }
+    const size = Math.trunc(byteLength);
+    return size + ((64 - (size % 64)) % 64);
+};
+export const createProcessSharedMemoryAllocator = (debug) => {
+    if (RUNTIME !== "node")
+        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 getProcessWorkerSharedMemoryPrimitives = () => {
+    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 processWorkerNeedsInheritedFd = (descriptor) => descriptor.name === undefined;
+const isWindowsRuntimeHost = () => {
+    const denoOs = globalThis.Deno?.build?.os;
+    if (denoOs !== undefined)
+        return denoOs === "windows";
+    return globalThis.process?.platform === "win32";
+};
+let processWorkerMemoryNameCounter = 0;
+const makeProcessWorkerMemoryName = (thread, prefix = "kpw") => {
+    const processId = globalThis.process?.pid ??
+        globalThis.Deno?.pid ??
+        0;
+    const next = processWorkerMemoryNameCounter++;
+    // Keep total ≤ 30 chars: macOS POSIX shm_open limit is 31 including the leading /.
+    const pidTag = Math.abs(processId).toString(36).slice(-4);
+    const threadTag = (thread % 4096).toString(36);
+    const nextTag = (next % 1296).toString(36);
+    const randomTag = Math.random().toString(36).slice(2, 7);
+    const safePrefix = (prefix.replace(/[^a-z0-9_-]/gi, "_") || "kpw").slice(0, 8);
+    return `${safePrefix}_${pidTag}_${threadTag}_${nextTag}_${randomTag}`;
+};
+export const createProcessWorkerMemoryLayout = ({ signalBytes, abortBytes, payloadBytes, thread, sharedMemory, }) => {
+    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 forceNamed = sharedMemory.mode === "named" || isWindowsRuntimeHost();
+    const mapping = primitives.createSharedMemory(forceNamed
+        ? {
+            size: carpet.byteLength(),
+            mode: "create",
+            name: makeProcessWorkerMemoryName(thread, 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 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,
+        controlLayout,
+        lockPayload: bind(requestPayloadSlice),
+        returnPayload: bind(returnPayloadSlice),
+        cleanup: () => {
+            const name = descriptor.name;
+            if (name !== undefined && sharedMemory.unlinkOnShutdown) {
+                primitives.unlinkSharedMemory?.(name);
+            }
+        },
+    };
+};
+const toChildProcessSharedBufferMetadata = (source, descriptor) => {
+    const region = toSharedBufferRegion(source);
+    const metadata = descriptor.toMetadata();
+    const childMetadata = processWorkerNeedsInheritedFd(descriptor)
+        ? { ...metadata, fd: PROCESS_WORKER_CHILD_FD }
+        : metadata;
+    return ProcessSharedBuffer.fromDescriptor(new FileDescriptor(childMetadata), {
+        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 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: {
+        ...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;
+};
+export const readProcessWorkerRuntime = (options) => {
+    const runtime = options?.processRuntime ?? "deno";
+    if (runtime === "bun" || runtime === "deno" || runtime === "node") {
+        return runtime;
+    }
+    throw new TypeError(`Unsupported process worker runtime: ${String(runtime)}`);
+};
+export 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 readProcessSharedMemoryMode = (value) => {
+    if (value === undefined)
+        return "inherit";
+    if (value === "inherit" || value === "named")
+        return value;
+    throw new TypeError(`Unsupported processSharedMemory mode: ${String(value)}`);
+};
+export const readProcessSharedMemorySettings = (options) => {
+    const input = options?.processSharedMemory;
+    if (input === undefined || typeof input === "string") {
+        return {
+            mode: readProcessSharedMemoryMode(input),
+            unlinkOnShutdown: true,
+        };
+    }
+    if (typeof input !== "object" || input === null) {
+        throw new TypeError("processSharedMemory must be a mode or options object");
+    }
+    const settings = input;
+    const mode = readProcessSharedMemoryMode(settings.mode);
+    const out = {
+        mode,
+        unlinkOnShutdown: settings.unlinkOnShutdown !== false,
+    };
+    if (settings.namePrefix !== undefined) {
+        if (typeof settings.namePrefix !== "string" ||
+            settings.namePrefix.length === 0 ||
+            settings.namePrefix.includes("\0")) {
+            throw new TypeError("processSharedMemory.namePrefix must be a non-empty string without NUL bytes");
+        }
+        out.namePrefix = settings.namePrefix;
+    }
+    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, commandPrefix) => getNodeProcess()?.env?.BUN_BINARY ??
+    (commandPrefix === undefined ? bun?.argv?.[0] : undefined) ??
+    DEFAULT_BUN_BINARY;
+const processWorkerDenoBinary = (deno, commandPrefix) => getNodeProcess()?.env?.DENO_BINARY ??
+    (commandPrefix === undefined ? deno?.execPath?.() : undefined) ??
+    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 = (commandPrefix) => {
+    const nodeProcess = getNodeProcess();
+    return nodeProcess?.env?.NODE_BINARY ??
+        (commandPrefix === undefined && 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, commandPrefix),
+            "run",
+            ...processWorkerDenoFlags(permission),
+            workerPath,
+        ];
+    }
+    else if (processRuntime === "node") {
+        command = [
+            processWorkerNodeBinary(commandPrefix),
+            ...processWorkerNodeExecArgv(),
+            workerPath,
+        ];
+    }
+    else {
+        command = [processWorkerBunBinary(bun, commandPrefix), workerPath];
+    }
+    return commandPrefix === undefined
+        ? command
+        : [...commandPrefix, ...command];
+};
+export 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: processWorkerNeedsInheritedFd(memory.descriptor)
+            ? memory.mapping.fd
+            : "ignore",
+        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" || processRuntime === "node") &&
+        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
+            ? [
+                processWorkerNeedsInheritedFd(memory.descriptor)
+                    ? memory.mapping.fd
+                    : "ignore",
+                "inherit",
+                "inherit",
+                "ipc",
+            ]
+            : [
+                processWorkerNeedsInheritedFd(memory.descriptor)
+                    ? memory.mapping.fd
+                    : "ignore",
+                "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 = processWorkerNeedsInheritedFd(memory.descriptor)
+        ? openDenoInheritedFd(memory.mapping.fd)
+        : undefined;
+    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: inheritedFd === undefined ? "null" : 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,
+    };
+};
+export 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");
+    }
+};
+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();
+    }
+    catch {
+    }
+};

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

@@ -9,7 +9,7 @@ type CreateHostTxQueueArgs = {
     max?: number;
     lock: Lock2;
     returnLock: Lock2;
-    abortSignals?: Pick<SignalAbortStore, "getSignal" | "resetSignal" | "closeNow">;
+    abortSignals?: Pick<SignalAbortStore, "getSignal" | "setSignal" | "resetSignal" | "closeNow">;
     now?: () => number;
 };
 export declare function createHostTxQueue({ max, lock, returnLock, abortSignals, now, }: CreateHostTxQueueArgs): {

package/src/runtime/tx-queue.js

@@ -98,7 +98,9 @@ export function createHostTxQueue({ max, lock, returnLock, abortSignals, now, })
                     if (maybeSignal === abortSignals.closeNow) {
                         return Promise.reject(AbortSignalPoolExhausted);
                     }
-                    new OneShotDeferred(deferred, () => resetSignal(maybeSignal));
+                    new OneShotDeferred(deferred, () => resetSignal(maybeSignal), () => {
+                        abortSignals.setSignal(maybeSignal);
+                    });
                     const encodedSignalMeta = ((maybeSignal + ABORT_SIGNAL_META_OFFSET) & FUNCTION_META_MASK) >>> 0;
                     slot[TaskIndex.FunctionID] =
                         ((encodedSignalMeta << FUNCTION_META_SHIFT) | functionIDMasked) >>> 0;

package/src/shared/abortSignal.d.ts

@@ -19,5 +19,5 @@ export declare const signalAbortFactory: ({ sab, maxSignals, }: {
 };
 export declare class OneShotDeferred<T> {
     #private;
-    constructor(deferred: ReturnType<typeof withResolvers<T>>, onSettle: () => void);
+    constructor(deferred: ReturnType<typeof withResolvers<T>>, onSettle: () => void, onEmptyReject?: () => void);
 }