knitting 0.1.56 → 0.1.60

package/src/runtime/inline-executor.js

@@ -1,27 +1,37 @@
 import { withResolvers } from "../common/with-resolvers.js";
 import RingQueue from "../ipc/tools/ring-queue.js";
 import { createRuntimeMessageChannel } from "../common/worker-runtime.js";
+// const objects, not `enum`s: Andromeda's Nova engine can't parse `enum`. Same
+// values and emit on Node/Deno/Bun.
+const SlotStateMacro = {
+    Free: -1,
+    Pending: 0,
+};
+const TimeoutKind = {
+    Reject: 0,
+    Resolve: 1,
+};
 const normalizeTimeout = (timeout) => {
     if (timeout == null)
         return undefined;
     if (typeof timeout === "number") {
         return timeout >= 0
-            ? { ms: timeout, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") }
+            ? { ms: timeout, kind: TimeoutKind.Reject, value: new Error("Task timeout") }
             : undefined;
     }
     const ms = timeout.time;
     if (!(ms >= 0))
         return undefined;
     if ("default" in timeout) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: timeout.default };
+        return { ms, kind: TimeoutKind.Resolve, value: timeout.default };
     }
     if (timeout.maybe === true) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: undefined };
+        return { ms, kind: TimeoutKind.Resolve, value: undefined };
     }
     if ("error" in timeout) {
-        return { ms, kind: 0 /* TimeoutKind.Reject */, value: timeout.error };
+        return { ms, kind: TimeoutKind.Reject, value: timeout.error };
     }
-    return { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") };
+    return { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") };
 };
 const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
     let done = false;
@@ -29,7 +39,7 @@ const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
         if (done)
             return;
         done = true;
-        if (spec.kind === 1 /* TimeoutKind.Resolve */) {
+        if (spec.kind === TimeoutKind.Resolve) {
             resolve(spec.value);
         }
         else {
@@ -52,8 +62,10 @@ const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
 });
 const INLINE_ABORT_TOOLKIT = (() => {
     const hasAborted = () => false;
+    const now = () => performance.now();
     return {
         hasAborted,
+        now,
     };
 })();
 const composeInlineCallable = (fn, timeout, useAbortToolkit = false) => {
@@ -86,7 +98,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     });
     const initCap = 16;
     let fnByIndex = new Int32Array(initCap);
-    let stateByIndex = new Int8Array(initCap).fill(-1 /* SlotStateMacro.Free */);
+    let stateByIndex = new Int8Array(initCap).fill(SlotStateMacro.Free);
     let argsByIndex = new Array(initCap);
     let taskIdByIndex = new Array(initCap).fill(-1);
     let deferredByIndex = new Array(initCap);
@@ -126,13 +138,13 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         send();
     };
     const enqueueIfCurrent = (index, taskID) => {
-        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+        if (stateByIndex[index] !== SlotStateMacro.Pending ||
             taskIdByIndex[index] !== taskID)
             return;
         enqueue(index);
     };
     const settleIfCurrent = (index, taskID, isError, value) => {
-        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+        if (stateByIndex[index] !== SlotStateMacro.Pending ||
             taskIdByIndex[index] !== taskID)
             return;
         const deferred = deferredByIndex[index];
@@ -153,7 +165,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         nextFnByIndex.set(fnByIndex);
         fnByIndex = nextFnByIndex;
         const nextStateByIndex = new Int8Array(newCap);
-        nextStateByIndex.fill(-1 /* SlotStateMacro.Free */);
+        nextStateByIndex.fill(SlotStateMacro.Free);
         nextStateByIndex.set(stateByIndex);
         stateByIndex = nextStateByIndex;
         argsByIndex.length = newCap;
@@ -172,7 +184,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
             if (maybeIndex === undefined)
                 break;
             const index = maybeIndex | 0;
-            if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+            if (stateByIndex[index] !== SlotStateMacro.Pending)
                 continue;
             const taskID = taskIdByIndex[index];
             try {
@@ -213,7 +225,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     }
     function cleanup(index) {
         working--;
-        stateByIndex[index] = -1 /* SlotStateMacro.Free */;
+        stateByIndex[index] = SlotStateMacro.Free;
         fnByIndex[index] = 0;
         taskIdByIndex[index] = -1;
         argsByIndex[index] = undefined;
@@ -230,7 +242,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
         argsByIndex[index] = args;
         fnByIndex[index] = fnNumber | 0;
         deferredByIndex[index] = deferred;
-        stateByIndex[index] = 0 /* SlotStateMacro.Pending */;
+        stateByIndex[index] = SlotStateMacro.Pending;
         working++;
         if (args instanceof Promise) {
             args.then((value) => {
@@ -250,7 +262,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
     return {
         kills: async () => {
             for (let index = 0; index < stateByIndex.length; index++) {
-                if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+                if (stateByIndex[index] !== SlotStateMacro.Pending)
                     continue;
                 try {
                     deferredByIndex[index]?.reject("Thread closed");
@@ -271,7 +283,7 @@ export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
             taskIdByIndex.fill(-1);
             deferredByIndex.fill(undefined);
             fnByIndex.fill(0);
-            stateByIndex.fill(-1 /* SlotStateMacro.Free */);
+            stateByIndex.fill(SlotStateMacro.Free);
             working = 0;
             isInMacro = false;
             isInMicro = false;

package/src/runtime/pool.d.ts

@@ -2,6 +2,7 @@ import { type ProcessSharedMemoryBacking } from "./process-worker.js";
 import { type Sab } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, type DispatcherCheck } from "./dispatcher.js";
 import { lock2 } from "../memory/lock.js";
+import "../memory/payloadCodec.js";
 import type { DebugOptions, DispatcherSettings, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
 import "../worker/loop.js";
 import { type PayloadBufferOptions } from "../memory/payload-config.js";
@@ -29,11 +30,15 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
      * macro channel that runs all lane checks.
      */
     sharedChannelHandler?: ChannelHandler;
-}) => WorkerContext & {
+}) => (WorkerContext & {
+    dispatcherCheck?: never;
+    laneWake?: never;
+    bindSend?: never;
+}) | (WorkerContext & {
     lock: ReturnType<typeof lock2>;
     processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
     dispatcherCheck?: DispatcherCheck;
     laneWake?: () => void;
     bindSend?: (fn: () => void) => void;
-};
+});
 export type CreateContext = WorkerContext;

package/src/runtime/pool.js

@@ -3,6 +3,9 @@ import { cleanupProcessWorkerMemoryQuietly, createProcessSharedMemoryAllocator,
 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 { HAS_NODE_WORKER_THREADS, RUNTIME_WORKER, } from "../common/worker-runtime.js";
@@ -10,7 +13,8 @@ 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" &&
@@ -35,6 +39,16 @@ const withFixedPayloadConfig = (config) => ({
     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, }) => {
+    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));
@@ -144,6 +158,7 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         payloadSector: lockBuffers.payloadSector,
         payloadConfig: resolvedPayloadConfig,
         textCompat: lockBuffers.textCompat,
+        processBoundary: useProcessWorkerRuntime,
     });
     const returnLock = lock2({
         headers: returnLockBuffers.headers,
@@ -153,6 +168,7 @@ 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
@@ -178,13 +194,61 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         processRuntime: processWorkerRuntime,
         signal: signalBox.opView,
     });
+    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 queue = createHostTxQueue({
         lock,
         returnLock,
         abortSignals,
         releaseBufferReferenceReturn: bufferReferenceReturn === "borrow"
-            ? (token) => {
-                worker?.postMessage?.(createBufferReferenceReturnReleaseMessage(token));
+            ? {
+                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,
     });
@@ -325,17 +389,21 @@ export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, hostD
         worker.postMessage?.(workerDataPayload);
     }
     let closedReason;
-    const markWorkerClosed = (reason) => {
+    // `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]}`);
+        markWorkerClosed(`Worker startup failed: ${message[WORKER_FATAL_MESSAGE_KEY]}`, true);
         terminateWorkerQuietly(worker);
     };
     const onWorkerError = (error) => {
@@ -388,7 +456,7 @@ 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);
         },

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

@@ -36,7 +36,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";

package/src/runtime/process-worker.js

@@ -1,4 +1,3 @@
-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";
@@ -12,6 +11,15 @@ 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";
+// `node:url` resolved lazily so this module evaluates on runtimes without it
+// (e.g. Andromeda); process workers aren't used there, so it never runs.
+const fileURLToPathCompat = (value) => {
+    const url = getNodeBuiltinModule("node:url");
+    if (url === undefined) {
+        throw new Error("node:url is not available in this runtime");
+    }
+    return url.fileURLToPath(value);
+};
 const execFlagKey = (flag) => flag.split("=", 1)[0];
 const NODE_PERMISSION_EXEC_FLAGS = new Set([
     "--permission",
@@ -20,10 +28,13 @@ const NODE_PERMISSION_EXEC_FLAGS = new Set([
     "--allow-fs-write",
     "--allow-worker",
     "--allow-child-process",
+    "--allow-net",
     "--allow-addons",
+    "--allow-ffi",
     "--allow-wasi",
 ]);
 const NODE_WORKER_SAFE_EXEC_FLAGS = new Set([
+    "--experimental-ffi",
     "--experimental-transform-types",
     "--expose-gc",
     "--no-warnings",
@@ -107,10 +118,23 @@ 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 nodeMajorVersion = () => {
+    const version = getNodeProcess()?.versions?.node ?? "";
+    const major = Number.parseInt(version.split(".", 1)[0] ?? "", 10);
+    return Number.isInteger(major) ? major : 0;
+};
+const nodeProcessWorkerUsesFfi = () => {
+    const major = nodeMajorVersion();
+    return major >= 26 && major % 2 === 0;
+};
+const nodeProcessWorkerInternalExecArgv = () => {
+    return [
+        "--no-warnings",
+        ...(nodeProcessWorkerUsesFfi()
+            ? ["--experimental-ffi"]
+            : ["--experimental-transform-types"]),
+    ];
+};
 const getProcessWorkerSharedMemoryPrimitives = () => {
     switch (RUNTIME) {
         case "bun":
@@ -393,7 +417,7 @@ const processWorkerNodeBinary = (commandPrefix) => {
             : undefined) ??
         DEFAULT_NODE_BINARY;
 };
-const processWorkerNodeExecArgv = () => {
+const processWorkerNodeExecArgv = (permission) => {
     const out = [];
     const seen = new Set();
     const add = (flag) => {
@@ -405,8 +429,17 @@ const processWorkerNodeExecArgv = () => {
     for (const flag of toWorkerCompatExecArgv(getNodeProcess()?.execArgv) ?? []) {
         add(flag);
     }
-    for (const flag of NODE_PROCESS_WORKER_EXEC_ARGV)
+    for (const flag of nodeProcessWorkerInternalExecArgv())
         add(flag);
+    if (permission?.enabled === true && permission.unsafe !== true) {
+        for (const flag of permission.node.flags)
+            add(flag);
+        if (permission.netAll && nodeMajorVersion() >= 25)
+            add("--allow-net");
+        // Node process workers need one native transport capability regardless of
+        // task permissions: addons on Node 22/24, node:ffi on supported Node 26+ LTS.
+        add(nodeProcessWorkerUsesFfi() ? "--allow-ffi" : "--allow-addons");
+    }
     return out;
 };
 const processWorkerCommand = ({ processRuntime, workerUrl, bun, deno, commandPrefix, permission, }) => {
@@ -423,7 +456,7 @@ const processWorkerCommand = ({ processRuntime, workerUrl, bun, deno, commandPre
     else if (processRuntime === "node") {
         command = [
             processWorkerNodeBinary(commandPrefix),
-            ...processWorkerNodeExecArgv(),
+            ...processWorkerNodeExecArgv(permission),
             workerPath,
         ];
     }
@@ -670,4 +703,11 @@ export const cleanupProcessWorkerMemoryQuietly = (memory) => {
     }
     catch {
     }
+    finally {
+        try {
+            memory?.mapping.close?.();
+        }
+        catch {
+        }
+    }
 };

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

@@ -1,6 +1,8 @@
+import "../memory/payloadCodec.js";
 import { type Lock2, type Task } from "../memory/lock.js";
 import type { AbortSignalOption, TaskTimeout } from "../types.js";
 import { type SignalAbortStore } from "../shared/abortSignal.js";
+import { type BufferReferenceReturnHooks } from "../connections/buffer-reference.js";
 type RawArguments = unknown;
 type FunctionID = number;
 type QueueTask = Task;
@@ -9,7 +11,7 @@ type CreateHostTxQueueArgs = {
     max?: number;
     lock: Lock2;
     returnLock: Lock2;
-    releaseBufferReferenceReturn?: (token: bigint) => void;
+    releaseBufferReferenceReturn?: ((token: bigint) => void) | BufferReferenceReturnHooks;
     abortSignals?: Pick<SignalAbortStore, "getSignal" | "setSignal" | "resetSignal" | "closeNow">;
     now?: () => number;
 };

package/src/runtime/tx-queue.js

@@ -1,7 +1,10 @@
+// Side-effect import: registers the payload codec (cycle break for Andromeda;
+// see lock.ts), ensuring registration before any lock2() call.
+import "../memory/payloadCodec.js";
 import { makeTask, resetTaskLocalFlags, runTaskFinalizers, TaskIndex, } from "../memory/lock.js";
 import { withResolvers } from "../common/with-resolvers.js";
 import { AbortSignalPoolExhausted, OneShotDeferred, } from "../shared/abortSignal.js";
-import { withBufferReferenceReturnReleaser } from "../connections/buffer-reference.js";
+import { withBufferReferenceReturnReleaser, } from "../connections/buffer-reference.js";
 const SLOT_INDEX_MASK = 31;
 const SLOT_META_MASK = 0x07ffffff;
 const SLOT_META_SHIFT = 5;

package/src/types.d.ts

@@ -83,6 +83,7 @@ type AbortSignalConfig = {
 type AbortSignalOption = true | AbortSignalConfig | undefined;
 type AbortSignalMethods<AS extends AbortSignalOption> = AS extends undefined ? never : {
     hasAborted: () => boolean;
+    now: () => number;
 };
 type AbortSignalToolkit<AS extends AbortSignalOption> = AbortSignalMethods<AS>;
 type TaskFn<A extends TaskInput, B extends Args, AS extends AbortSignalOption = undefined> = BivariantCallback<AS extends undefined ? [NoBlob<Awaited<A>>] : [NoBlob<Awaited<A>>, AbortSignalToolkit<AS>], MaybePromise<NoBlob<B>>>;
@@ -220,6 +221,41 @@ type WorkerBootstrapOptions<Data = unknown> = {
      */
     data?: Data;
 };
+/** Native worker artifact and on-demand compiler settings. */
+type CompiledWorkerOptions = {
+    /**
+     * Native executable path. Relative paths resolve from the createPool caller.
+     * Defaults to the task module path with its extension replaced by `.knt`.
+     */
+    artifact?: string;
+    /**
+     * Versioned metadata sidecar. Defaults to `<artifact>.json`.
+     */
+    manifest?: string;
+    /**
+     * Build a missing/incompatible artifact, or use `"always"` to rebuild once
+     * whenever a pool is created. Defaults to true.
+     */
+    build?: boolean | "always";
+    /**
+     * Porffor main executable or checkout. Defaults to PORFFOR_MAIN/PORF, then
+     * `porf` on PATH; a pinned compiler is cached locally when none is present.
+     */
+    compiler?: string;
+};
+type CompiledWorkerSource = string | URL | {
+    readonly importedFrom: string;
+};
+type CompiledWorkerCheck = {
+    /** True only when the executable and compatible manifest both validate. */
+    compiled: boolean;
+    artifact: string;
+    manifest: string;
+    reason?: string;
+    compiler?: string;
+    protocol?: string;
+    tasks?: readonly string[];
+};
 type WorkerSettings = {
     resolveAfterFinishingAll?: true;
     /**
@@ -230,13 +266,18 @@ type WorkerSettings = {
     /**
      * Experimental worker runtime.
      * "thread" uses Worker/worker_threads. "process" spawns another JavaScript
-     * runtime, useful for process isolation, bwrap, and containers.
+     * runtime, useful for process isolation, bwrap, and containers. "compiled"
+     * validates and runs a `.knt` native worker, building it on first use.
      */
-    runtime?: "thread" | "process";
+    runtime?: "thread" | "process" | "compiled";
+    /** Artifact settings used when runtime is "compiled". */
+    compiled?: CompiledWorkerOptions;
     /**
-     * Runtime executable to use when runtime is "process". Defaults to "deno".
+     * Runtime executable for process workers. Standalone `"porffor"` selects the
+     * compiled backend and rebuilds once per pool; with `runtime: "compiled"` it
+     * reuses the validated artifact.
      */
-    processRuntime?: "bun" | "deno" | "node";
+    processRuntime?: "bun" | "deno" | "node" | "porffor";
     /**
      * Command argv to prepend before the process worker runtime command.
      * Useful for wrappers such as systemd-run, cgexec, nice, taskset, or
@@ -351,7 +392,8 @@ type CreatePool = {
     debug?: DebugOptions;
     source?: string;
 };
-export type { AbortSignalConfig as AbortSignalConfig, AbortSignalMethods as AbortSignalMethods, AbortSignalOption as AbortSignalOption, AbortSignalToolkit as AbortSignalToolkit, Args as Args, Balancer as Balancer, BalancerStrategy as BalancerStrategy, Composed as Composed, ComposedWithKey as ComposedWithKey, CreateContext as CreateContext, CreatePool as CreatePool, DebugNamespace as DebugNamespace, DebugOptions as DebugOptions, DispatcherSettings as DispatcherSettings, Envelope as Envelope, EnvelopeBody as EnvelopeBody, EnvelopeHeader as EnvelopeHeader, External as External, FixPoint as FixPoint, FunctionMapType as FunctionMapType, ImportTaskOptions as ImportTaskOptions, Inliner as Inliner, LockBuffers as LockBuffers, LockBufferTextCompat as LockBufferTextCompat, MaybePromise as MaybePromise, PayloadBufferMode as PayloadBufferMode, PayloadBufferOptions as PayloadBufferOptions, PermissionProtocol as PermissionProtocol, PermissionProtocolInput as PermissionProtocolInput, Pool as Pool, ProcessSharedMemoryMode as ProcessSharedMemoryMode, ProcessSharedMemorySettings as ProcessSharedMemorySettings, ResolvedPermissionProtocol as ResolvedPermissionProtocol, ReturnFixed as ReturnFixed, SecondPart as SecondPart, SharedBufferRegion as SharedBufferRegion, SharedBufferSource as SharedBufferSource, SharedBufferTextCompat as SharedBufferTextCompat, SingleTaskPool as SingleTaskPool, TaskFn as TaskFn, TaskInput as TaskInput, tasks as tasks, TaskTimeout as TaskTimeout, ValidInput as ValidInput, WorkerBootstrapContext as WorkerBootstrapContext, WorkerBootstrapFunction as WorkerBootstrapFunction, WorkerBootstrapOptions as WorkerBootstrapOptions, WorkerCall as WorkerCall, WorkerContext as WorkerContext, WorkerData as WorkerData, WorkerInvoke as WorkerInvoke, WorkerSettings as WorkerSettings, WorkerTimers as WorkerTimers, };
-export type { Task as Task } from "./memory/lock.js";
+export type { AbortSignalConfig as AbortSignalConfig, AbortSignalMethods as AbortSignalMethods, AbortSignalOption as AbortSignalOption, AbortSignalToolkit as AbortSignalToolkit, Args as Args, Balancer as Balancer, BalancerStrategy as BalancerStrategy, CompiledWorkerCheck as CompiledWorkerCheck, CompiledWorkerOptions as CompiledWorkerOptions, CompiledWorkerSource as CompiledWorkerSource, Composed as Composed, ComposedWithKey as ComposedWithKey, CreateContext as CreateContext, CreatePool as CreatePool, DebugNamespace as DebugNamespace, DebugOptions as DebugOptions, DispatcherSettings as DispatcherSettings, Envelope as Envelope, EnvelopeBody as EnvelopeBody, EnvelopeHeader as EnvelopeHeader, External as External, FixPoint as FixPoint, FunctionMapType as FunctionMapType, ImportTaskOptions as ImportTaskOptions, Inliner as Inliner, LockBuffers as LockBuffers, LockBufferTextCompat as LockBufferTextCompat, MaybePromise as MaybePromise, PayloadBufferMode as PayloadBufferMode, PayloadBufferOptions as PayloadBufferOptions, PermissionProtocol as PermissionProtocol, PermissionProtocolInput as PermissionProtocolInput, Pool as Pool, ProcessSharedMemoryMode as ProcessSharedMemoryMode, ProcessSharedMemorySettings as ProcessSharedMemorySettings, ResolvedPermissionProtocol as ResolvedPermissionProtocol, ReturnFixed as ReturnFixed, SecondPart as SecondPart, SharedBufferRegion as SharedBufferRegion, SharedBufferSource as SharedBufferSource, SharedBufferTextCompat as SharedBufferTextCompat, SingleTaskPool as SingleTaskPool, TaskFn as TaskFn, TaskInput as TaskInput, tasks as tasks, TaskTimeout as TaskTimeout, ValidInput as ValidInput, WorkerBootstrapContext as WorkerBootstrapContext, WorkerBootstrapFunction as WorkerBootstrapFunction, WorkerBootstrapOptions as WorkerBootstrapOptions, WorkerCall as WorkerCall, WorkerContext as WorkerContext, WorkerData as WorkerData, WorkerInvoke as WorkerInvoke, WorkerSettings as WorkerSettings, WorkerTimers as WorkerTimers, };
+import type { Task as TaskType } from "./memory/lock.js";
 export { LockBound as LockBound, PayloadBuffer as PayloadBuffer, PayloadSignal as PayloadSignal, TaskIndex as TaskIndex, } from "./memory/lock.js";
+export type Task = TaskType;
 export type { RegisterMalloc as RegisterMalloc } from "./memory/regionRegistry.js";

package/src/worker/composable-runners.js

@@ -49,7 +49,7 @@ const readSignal = (slot) => {
     const signal = (encodedSignal - ABORT_SIGNAL_META_OFFSET) | 0;
     return signal >= 0 ? signal : NO_ABORT_SIGNAL;
 };
-const makeToolkitCache = (hasAborted) => {
+const makeToolkitCache = (hasAborted, now) => {
     const bySignal = [];
     return (signal) => {
         let toolkit = bySignal[signal];
@@ -58,6 +58,7 @@ const makeToolkitCache = (hasAborted) => {
         const hasAbortedMethod = () => hasAborted(signal);
         toolkit = {
             hasAborted: hasAbortedMethod,
+            now,
         };
         bySignal[signal] = toolkit;
         return toolkit;
@@ -76,7 +77,7 @@ export const composeWorkerRunner = ({ job, timeout, hasAborted, now, }) => {
             return applyTimeoutBudget(result, slot, timeout, nowTime);
         };
     }
-    const getToolkit = makeToolkitCache(hasAborted);
+    const getToolkit = makeToolkitCache(hasAborted, nowTime);
     if (!timeout) {
         return (slot) => {
             const signal = readSignal(slot);

package/src/worker/loop.d.ts

@@ -1,2 +1,3 @@
+import "../memory/payloadCodec.js";
 import type { WorkerData } from "../types.js";
 export declare const workerMainLoop: (startupData: WorkerData) => Promise<void>;

package/src/worker/loop.js

@@ -4,9 +4,12 @@ import { isLockBufferTextCompat } from "../common/shared-buffer-text.js";
 import { createWorkerRxQueue } from "./rx-queue.js";
 import { createSharedMemoryTransport } from "../ipc/transport/shared-memory.js";
 import { lock2 } 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 { getFunctions } from "./task-loader.js";
 import { pauseGeneric, sleepUntilChanged, whilePausing } from "./timers.js";
-import { RUNTIME, SET_IMMEDIATE } from "../common/runtime.js";
+import { IS_ANDROMEDA, RUNTIME, SET_IMMEDIATE } from "../common/runtime.js";
 import { getNodeProcess } from "../common/node-compat.js";
 import { assertWorkerImportsResolved, assertWorkerSharedMemoryBootData, installPerformanceNowGuard, installTerminationGuard, installUnhandledRejectionSilencer, scrubWorkerDataSensitiveBuffers, } from "./safety/index.js";
 import { signalAbortFactory } from "../shared/abortSignal.js";
@@ -81,10 +84,10 @@ export const workerMainLoop = async (startupData) => {
             namespaces: debugNamespaces,
         }))
         : undefined;
-    let Comment;
-    (function (Comment) {
-        Comment[Comment["thisIsAHint"] = 0] = "thisIsAHint";
-    })(Comment || (Comment = {}));
+    // const object, not `enum`: Andromeda's Nova engine can't parse `enum`.
+    const Comment = {
+        thisIsAHint: 0,
+    };
     const signals = createSharedMemoryTransport({
         sabObject: {
             sharedSab: sab,
@@ -101,6 +104,7 @@ export const workerMainLoop = async (startupData) => {
         payloadSector: lock.payloadSector,
         payloadConfig,
         textCompat: lock.textCompat,
+        processBoundary: RUNTIME_IS_PROCESS_WORKER,
     });
     const returnLockState = lock2({
         headers: returnLock.headers,
@@ -110,6 +114,7 @@ export const workerMainLoop = async (startupData) => {
         payloadSector: returnLock.payloadSector,
         payloadConfig,
         textCompat: returnLock.textCompat,
+        processBoundary: RUNTIME_IS_PROCESS_WORKER,
     });
     const timers = workerOptions?.timers;
     const spinMicroseconds = timers?.spinMicroseconds ??
@@ -295,15 +300,23 @@ export const workerMainLoop = async (startupData) => {
 };
 const isWorkerGlobalScope = () => {
     const scopeCtor = globalThis.WorkerGlobalScope;
-    if (typeof scopeCtor !== "function")
-        return false;
-    try {
-        return globalThis instanceof
-            scopeCtor;
+    if (typeof scopeCtor === "function") {
+        try {
+            if (globalThis instanceof scopeCtor) {
+                return true;
+            }
+        }
+        catch {
+            // fall through to runtime-specific checks
+        }
     }
-    catch {
-        return false;
+    // Andromeda has no `WorkerGlobalScope`; its worker scope carries a `self`
+    // global that the main thread lacks.
+    if (IS_ANDROMEDA &&
+        typeof globalThis.self !== "undefined") {
+        return true;
     }
+    return false;
 };
 const isLockBuffers = (value) => {
     if (!value || typeof value !== "object")