knitting 0.1.46

package/src/runtime/balancer.js

@@ -0,0 +1,149 @@
+const selectStrategy = (contexts, handlers, strategy) => {
+    switch (strategy ?? "roundRobin") {
+        case "roundRobin":
+        case "robinRound": // legacy alias
+            return roundRobin(contexts)(handlers)(handlers.length);
+        case "firstIdle":
+            return firstIdle(contexts)(handlers)(handlers.length);
+        case "randomLane":
+            return randomLane(contexts)(handlers)(handlers.length);
+        case "firstIdleOrRandom":
+            return firstIdleRandom(contexts)(handlers)(handlers.length);
+    }
+    // Unreachable code, but guarded for safety.
+    throw new Error(`Unknown balancer: ${strategy}`);
+};
+export const managerMethod = ({ contexts, balancer, handlers, inlinerGate, }) => {
+    const strategy = typeof balancer === "object" && balancer != null
+        ? balancer.strategy
+        : balancer;
+    if (contexts.length < 2) {
+        throw new Error(contexts.length === 0
+            ? "No threads available."
+            : "Cannot rotate with a single thread.");
+    }
+    if (handlers.length === 0) {
+        throw new Error("No handlers provided.");
+    }
+    const allInvoker = selectStrategy(contexts, handlers, strategy);
+    if (!inlinerGate) {
+        return allInvoker;
+    }
+    const inlinerIndex = inlinerGate.index | 0;
+    const threshold = Number.isFinite(inlinerGate.threshold)
+        ? Math.max(1, Math.floor(inlinerGate.threshold))
+        : 1;
+    if (threshold <= 1 || inlinerIndex < 0 || inlinerIndex >= handlers.length) {
+        return allInvoker;
+    }
+    const workerLaneCount = handlers.length - 1;
+    if (workerLaneCount <= 0) {
+        return allInvoker;
+    }
+    const workerHandlers = new Array(workerLaneCount);
+    const workerContexts = new Array(workerLaneCount);
+    for (let source = 0, lane = 0; source < handlers.length; source += 1) {
+        if (source === inlinerIndex)
+            continue;
+        workerHandlers[lane] = handlers[source];
+        workerContexts[lane] = contexts[source];
+        lane += 1;
+    }
+    const workerOnlyInvoker = selectStrategy(workerContexts, workerHandlers, strategy);
+    let inFlight = 0;
+    const releaseResolved = (value) => {
+        inFlight -= 1;
+        return value;
+    };
+    const releaseRejected = (error) => {
+        inFlight -= 1;
+        throw error;
+    };
+    return (args) => {
+        inFlight += 1;
+        const invoker = inFlight >= threshold ? allInvoker : workerOnlyInvoker;
+        try {
+            return invoker(args).then(releaseResolved, releaseRejected);
+        }
+        catch (error) {
+            inFlight -= 1;
+            throw error;
+        }
+    };
+};
+export function roundRobin(_contexts) {
+    return (handlers) => {
+        return (max) => {
+            const top = Math.min(max, handlers.length);
+            if (top <= 1) {
+                return (args) => handlers[0](args);
+            }
+            let rrCursor = 0;
+            return (args) => {
+                const lane = rrCursor;
+                rrCursor += 1;
+                if (rrCursor === top)
+                    rrCursor = 0;
+                return handlers[lane](args);
+            };
+        };
+    };
+}
+export function firstIdle(contexts) {
+    const isSolved = contexts.map((ctx) => ctx.txIdle);
+    return (handlers) => {
+        return (max) => {
+            const laneCount = Math.min(max, handlers.length);
+            if (laneCount <= 1) {
+                return (args) => handlers[0](args);
+            }
+            let rrCursor = 0;
+            return (args) => {
+                for (let lane = 0; lane < laneCount; lane += 1) {
+                    if (isSolved[lane]()) {
+                        return handlers[lane](args);
+                    }
+                }
+                const fallback = rrCursor;
+                rrCursor += 1;
+                if (rrCursor === laneCount)
+                    rrCursor = 0;
+                return handlers[fallback](args);
+            };
+        };
+    };
+}
+export const randomLane = (_) => {
+    return (handlers) => {
+        return (max) => {
+            const laneCount = Math.min(max, handlers.length);
+            if (laneCount <= 1) {
+                return (args) => handlers[0](args);
+            }
+            return (args) => {
+                const lane = (Math.random() * laneCount) | 0;
+                return handlers[lane](args);
+            };
+        };
+    };
+};
+export function firstIdleRandom(contexts) {
+    const isSolved = contexts.map((ctx) => ctx.txIdle);
+    return (handlers) => {
+        return (max) => {
+            const laneCount = Math.min(max, handlers.length);
+            if (laneCount <= 1) {
+                return (args) => handlers[0](args);
+            }
+            return (args) => {
+                for (let lane = 0; lane < laneCount; lane += 1) {
+                    if (isSolved[lane]()) {
+                        return handlers[lane](args);
+                    }
+                }
+                const fallback = (Math.random() * laneCount) | 0;
+                return handlers[fallback](args);
+            };
+        };
+    };
+}

package/src/runtime/dispatcher.d.ts

@@ -0,0 +1,34 @@
+import { type MultiQueue } from "./tx-queue.js";
+import { type MainSignal } from "../ipc/transport/shared-memory.js";
+import { type RuntimeMessageChannelLike, type RuntimeMessagePortLike } from "../common/worker-runtime.js";
+import type { DispatcherSettings } from "../types.js";
+export declare const hostDispatcherLoop: ({ signalBox: { opView, txStatus, rxStatus, }, queue: { completeFrame, hasPendingFrames, flushToWorker, txIdle, }, channelHandler, dispatcherOptions, notifySignal, }: {
+    queue: MultiQueue;
+    signalBox: MainSignal;
+    channelHandler: ChannelHandler;
+    dispatcherOptions?: DispatcherSettings;
+    notifySignal?: () => void;
+}) => {
+    check: {
+        (): void;
+        isRunning: boolean;
+        rerun: boolean;
+    };
+};
+export declare class ChannelHandler {
+    #private;
+    channel: RuntimeMessageChannelLike;
+    port1: RuntimeMessagePortLike;
+    port2: RuntimeMessagePortLike;
+    constructor();
+    notify(): void;
+    /**
+     * Opens the channel (if not already open) and sets the onmessage handler.
+     * This is the setup so `notify` can send a message to the port 1.
+     */
+    open(f: () => void): void;
+    /**
+     * Closes the channel if it is open.
+     */
+    close(): void;
+}

package/src/runtime/dispatcher.js

@@ -0,0 +1,142 @@
+import { createRuntimeMessageChannel, } from "../common/worker-runtime.js";
+export const hostDispatcherLoop = ({ signalBox: { opView, txStatus, rxStatus, }, queue: { completeFrame, hasPendingFrames, flushToWorker, txIdle, }, channelHandler, dispatcherOptions, notifySignal, }) => {
+    const a_load = Atomics.load;
+    const a_store = Atomics.store;
+    const a_notify = Atomics.notify;
+    const canNotifySignal = opView.buffer instanceof SharedArrayBuffer;
+    const wakeSignal = notifySignal ??
+        (() => {
+            if (canNotifySignal)
+                a_notify(opView, 0, 1);
+        });
+    const notify = () => channelHandler.notify();
+    let stallCount = 0 | 0;
+    const STALL_FREE_LOOPS = Math.max(0, (dispatcherOptions?.stallFreeLoops ?? 128) | 0);
+    const MAX_BACKOFF_MS = Math.max(0, (dispatcherOptions?.maxBackoffMs ?? 10) | 0);
+    let backoffTimer;
+    // inFlight prevents re-entrancy when pool.ts fires check() concurrently
+    // from both send() and the channel callback. Cheaper than try/finally.
+    let inFlight = false;
+    const check = () => {
+        if (inFlight) {
+            // Another check() is already mid-drain; mark that a re-run is needed
+            // so the active invocation loops again before yielding.
+            check.rerun = true;
+            return;
+        }
+        inFlight = true;
+        if (backoffTimer !== undefined) {
+            clearTimeout(backoffTimer);
+            backoffTimer = undefined;
+        }
+        do {
+            check.rerun = false;
+            txStatus[0] = 1;
+            // Wake the worker before draining so it can start processing while we flush.
+            if (a_load(rxStatus, 0) === 0) {
+                a_store(opView, 0, 1);
+                wakeSignal();
+            }
+            // Drain loop: local vars so V8 keeps them as unboxed int32.
+            let anyProgressed = false;
+            let progressed = true;
+            while (progressed) {
+                progressed = false;
+                if (completeFrame() > 0) {
+                    progressed = true;
+                    anyProgressed = true;
+                }
+                while (hasPendingFrames()) {
+                    if (!flushToWorker())
+                        break;
+                    progressed = true;
+                    anyProgressed = true;
+                }
+            }
+            txStatus[0] = 0;
+            if (!txIdle()) {
+                if (anyProgressed || hasPendingFrames()) {
+                    stallCount = 0 | 0;
+                }
+                else {
+                    stallCount = (stallCount + 1) | 0;
+                }
+                inFlight = false;
+                scheduleNotify();
+                return;
+            }
+            // Queue is fully drained.
+            stallCount = 0 | 0;
+        } while (check.rerun);
+        check.isRunning = false;
+        inFlight = false;
+    };
+    check.isRunning = false;
+    check.rerun = false;
+    const scheduleNotify = () => {
+        if (stallCount <= STALL_FREE_LOOPS) {
+            notify();
+            return;
+        }
+        // One delayed wakeup at a time; fresh send() calls preempt via check directly.
+        if (backoffTimer !== undefined)
+            return;
+        let delay = (stallCount - STALL_FREE_LOOPS - 1) | 0;
+        if (delay < 0)
+            delay = 0;
+        else if (delay > MAX_BACKOFF_MS)
+            delay = MAX_BACKOFF_MS;
+        // Release isRunning during backoff so pool.ts send() can restart the loop.
+        check.isRunning = false;
+        backoffTimer = setTimeout(() => {
+            backoffTimer = undefined;
+            if (!check.isRunning) {
+                check.isRunning = true;
+                check();
+            }
+        }, delay);
+    };
+    return { check };
+};
+export class ChannelHandler {
+    channel;
+    port1;
+    port2;
+    #post2;
+    constructor() {
+        this.channel = createRuntimeMessageChannel();
+        this.port1 = this.channel.port1;
+        this.port2 = this.channel.port2;
+        this.#post2 = (message) => this.port2.postMessage(message);
+    }
+    notify() {
+        this.#post2(null);
+    }
+    /**
+     * Opens the channel (if not already open) and sets the onmessage handler.
+     * This is the setup so `notify` can send a message to the port 1.
+     */
+    open(f) {
+        const port1 = this.port1;
+        if (typeof port1.on === "function") {
+            port1.on("message", f);
+        }
+        else {
+            // @ts-ignore
+            port1.onmessage = f;
+        }
+        this.port1.start?.();
+        this.port2.start?.();
+    }
+    /**
+     * Closes the channel if it is open.
+     */
+    close() {
+        //@ts-ignore
+        this.port1.onmessage = null;
+        //@ts-ignore
+        this.port2.onmessage = null;
+        this.port1.close?.();
+        this.port2.close?.();
+    }
+}

package/src/runtime/inline-executor.d.ts

@@ -0,0 +1,10 @@
+import type { WorkerCall, tasks } from "../types.js";
+export declare const createInlineExecutor: ({ tasks, genTaskID, batchSize, }: {
+    tasks: tasks;
+    genTaskID: () => number;
+    batchSize?: number;
+}) => {
+    readonly kills: () => Promise<void>;
+    readonly call: ({ fnNumber }: WorkerCall) => (args: unknown) => import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
+    readonly txIdle: () => boolean;
+};

package/src/runtime/inline-executor.js

@@ -0,0 +1,270 @@
+import { withResolvers } from "../common/with-resolvers.js";
+import RingQueue from "../ipc/tools/ring-queue.js";
+import { createRuntimeMessageChannel } from "../common/worker-runtime.js";
+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") }
+            : undefined;
+    }
+    const ms = timeout.time;
+    if (!(ms >= 0))
+        return undefined;
+    if ("default" in timeout) {
+        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: timeout.default };
+    }
+    if (timeout.maybe === true) {
+        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: undefined };
+    }
+    if ("error" in timeout) {
+        return { ms, kind: 0 /* TimeoutKind.Reject */, value: timeout.error };
+    }
+    return { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") };
+};
+const raceTimeout = (promise, spec) => new Promise((resolve, reject) => {
+    let done = false;
+    const timer = setTimeout(() => {
+        if (done)
+            return;
+        done = true;
+        if (spec.kind === 1 /* TimeoutKind.Resolve */) {
+            resolve(spec.value);
+        }
+        else {
+            reject(spec.value);
+        }
+    }, spec.ms);
+    promise.then((value) => {
+        if (done)
+            return;
+        done = true;
+        clearTimeout(timer);
+        resolve(value);
+    }, (err) => {
+        if (done)
+            return;
+        done = true;
+        clearTimeout(timer);
+        reject(err);
+    });
+});
+const INLINE_ABORT_TOOLKIT = (() => {
+    const hasAborted = () => false;
+    return {
+        hasAborted,
+    };
+})();
+const composeInlineCallable = (fn, timeout, useAbortToolkit = false) => {
+    const normalized = normalizeTimeout(timeout);
+    const run = useAbortToolkit
+        ? (args) => fn(args, INLINE_ABORT_TOOLKIT)
+        : fn;
+    if (!normalized)
+        return run;
+    return (args) => {
+        const result = run(args);
+        return result instanceof Promise ? raceTimeout(result, normalized) : result;
+    };
+};
+export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
+    const entries = Object.values(tasks)
+        .sort((a, b) => a.id - b.id);
+    const runners = entries.map((entry) => composeInlineCallable(entry.f, entry.timeout, entry.abortSignal !== undefined));
+    const initCap = 16;
+    let fnByIndex = new Int32Array(initCap);
+    let stateByIndex = new Int8Array(initCap).fill(-1 /* SlotStateMacro.Free */);
+    let argsByIndex = new Array(initCap);
+    let taskIdByIndex = new Array(initCap).fill(-1);
+    let deferredByIndex = new Array(initCap);
+    const freeStack = new Array(initCap);
+    let freeTop = initCap;
+    for (let i = 0; i < initCap; i++)
+        freeStack[i] = initCap - 1 - i;
+    const pendingQueue = new RingQueue(initCap);
+    let working = 0;
+    let isInMacro = false;
+    let isInMicro = false;
+    const batchLimit = Number.isFinite(batchSize)
+        ? Math.max(1, Math.floor(batchSize ?? 1))
+        : Number.POSITIVE_INFINITY;
+    const channel = createRuntimeMessageChannel();
+    const port1 = channel.port1;
+    const port2 = channel.port2;
+    const post2 = (message) => port2.postMessage(message);
+    const hasPending = () => pendingQueue.isEmpty === false;
+    const queueMicro = typeof queueMicrotask === "function"
+        ? queueMicrotask
+        : (callback) => Promise.resolve().then(callback);
+    const scheduleMacro = () => {
+        if (working === 0 || isInMacro)
+            return;
+        isInMacro = true;
+        post2(null);
+    };
+    const send = () => {
+        if (working === 0 || isInMacro || isInMicro)
+            return;
+        isInMicro = true;
+        queueMicro(runMicroLoop);
+    };
+    const enqueue = (index) => {
+        pendingQueue.push(index);
+        send();
+    };
+    const enqueueIfCurrent = (index, taskID) => {
+        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+            taskIdByIndex[index] !== taskID)
+            return;
+        enqueue(index);
+    };
+    const settleIfCurrent = (index, taskID, isError, value) => {
+        if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */ ||
+            taskIdByIndex[index] !== taskID)
+            return;
+        const deferred = deferredByIndex[index];
+        if (deferred) {
+            if (isError)
+                deferred.reject(value);
+            else
+                deferred.resolve(value);
+        }
+        cleanup(index);
+    };
+    function allocIndex() {
+        if (freeTop > 0)
+            return freeStack[--freeTop];
+        const oldCap = fnByIndex.length;
+        const newCap = oldCap << 1;
+        const nextFnByIndex = new Int32Array(newCap);
+        nextFnByIndex.set(fnByIndex);
+        fnByIndex = nextFnByIndex;
+        const nextStateByIndex = new Int8Array(newCap);
+        nextStateByIndex.fill(-1 /* SlotStateMacro.Free */);
+        nextStateByIndex.set(stateByIndex);
+        stateByIndex = nextStateByIndex;
+        argsByIndex.length = newCap;
+        taskIdByIndex.length = newCap;
+        taskIdByIndex.fill(-1, oldCap);
+        deferredByIndex.length = newCap;
+        for (let i = newCap - 1; i >= oldCap; --i) {
+            freeStack[freeTop++] = i;
+        }
+        return freeStack[--freeTop];
+    }
+    function processLoop(fromMicro = false) {
+        let processed = 0;
+        while (processed < batchLimit) {
+            const maybeIndex = pendingQueue.shiftNoClear();
+            if (maybeIndex === undefined)
+                break;
+            const index = maybeIndex | 0;
+            if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+                continue;
+            const taskID = taskIdByIndex[index];
+            try {
+                const args = argsByIndex[index];
+                const fnId = fnByIndex[index];
+                const res = runners[fnId](args);
+                if (!(res instanceof Promise)) {
+                    settleIfCurrent(index, taskID, false, res);
+                    processed++;
+                    continue;
+                }
+                res.then((value) => settleIfCurrent(index, taskID, false, value), (err) => settleIfCurrent(index, taskID, true, err));
+                processed++;
+            }
+            catch (err) {
+                settleIfCurrent(index, taskID, true, err);
+                processed++;
+            }
+        }
+        if (hasPending()) {
+            if (fromMicro) {
+                scheduleMacro();
+            }
+            else {
+                post2(null);
+            }
+            return;
+        }
+        if (!fromMicro) {
+            isInMacro = false;
+        }
+    }
+    function runMicroLoop() {
+        if (!isInMicro)
+            return;
+        processLoop(true);
+        isInMicro = false;
+    }
+    function cleanup(index) {
+        working--;
+        stateByIndex[index] = -1 /* SlotStateMacro.Free */;
+        fnByIndex[index] = 0;
+        taskIdByIndex[index] = -1;
+        argsByIndex[index] = undefined;
+        deferredByIndex[index] = undefined;
+        freeStack[freeTop++] = index;
+        if (working === 0)
+            isInMacro = false;
+    }
+    const call = ({ fnNumber }) => (args) => {
+        const taskID = genTaskID();
+        const deferred = withResolvers();
+        const index = allocIndex();
+        taskIdByIndex[index] = taskID;
+        argsByIndex[index] = args;
+        fnByIndex[index] = fnNumber | 0;
+        deferredByIndex[index] = deferred;
+        stateByIndex[index] = 0 /* SlotStateMacro.Pending */;
+        working++;
+        if (args instanceof Promise) {
+            args.then((value) => {
+                if (taskIdByIndex[index] !== taskID)
+                    return;
+                argsByIndex[index] = value;
+                enqueueIfCurrent(index, taskID);
+            }, (err) => settleIfCurrent(index, taskID, true, err));
+        }
+        else {
+            enqueue(index);
+        }
+        return deferred.promise;
+    };
+    //@ts-ignore
+    port1.onmessage = () => processLoop(false);
+    return {
+        kills: async () => {
+            for (let index = 0; index < stateByIndex.length; index++) {
+                if (stateByIndex[index] !== 0 /* SlotStateMacro.Pending */)
+                    continue;
+                try {
+                    deferredByIndex[index]?.reject("Thread closed");
+                }
+                catch {
+                }
+            }
+            //@ts-ignore
+            port1.onmessage = null;
+            port1.close?.();
+            //@ts-ignore
+            port2.onmessage = null;
+            port2.close?.();
+            pendingQueue.clear();
+            freeTop = 0;
+            freeStack.length = 0;
+            argsByIndex.fill(undefined);
+            taskIdByIndex.fill(-1);
+            deferredByIndex.fill(undefined);
+            fnByIndex.fill(0);
+            stateByIndex.fill(-1 /* SlotStateMacro.Free */);
+            working = 0;
+            isInMacro = false;
+            isInMicro = false;
+        },
+        call,
+        txIdle: () => working === 0,
+    };
+};

package/src/runtime/pool.d.ts

@@ -0,0 +1,43 @@
+import { type Sab } from "../ipc/transport/shared-memory.js";
+import { lock2 } from "../memory/lock.js";
+import type { DebugOptions, DispatcherSettings, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
+import "../worker/loop.js";
+import { type PayloadBufferOptions } from "../memory/payload-config.js";
+type ProcessSharedMemoryNativeMapping = {
+    sab: SharedArrayBuffer;
+    fd: number;
+    size: number;
+    baseAddressMod64?: number;
+};
+type ProcessSharedMemoryBacking = ProcessSharedMemoryNativeMapping & {
+    runtime: "node";
+    buffer: SharedArrayBuffer;
+    kind: "shared-array-buffer";
+    byteLength: number;
+};
+export declare const spawnWorkerContext: ({ list, ids, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }: {
+    list: string[];
+    ids: number[];
+    at: number[];
+    sab?: Sab;
+    thread: number;
+    debug?: DebugOptions;
+    totalNumberOfThread: number;
+    source?: string;
+    workerOptions?: WorkerSettings;
+    workerExecArgv?: string[];
+    permission?: WorkerData["permission"];
+    host?: DispatcherSettings;
+    payload?: PayloadBufferOptions;
+    payloadInitialBytes?: number;
+    payloadMaxBytes?: number;
+    bufferMode?: PayloadBufferOptions["mode"];
+    maxPayloadBytes?: number;
+    abortSignalCapacity?: number;
+    usesAbortSignal?: boolean;
+}) => WorkerContext & {
+    lock: ReturnType<typeof lock2>;
+    processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
+};
+export type CreateContext = WorkerContext;
+export {};