knitting 0.1.53 → 0.1.55

package/src/runtime/balancer.js

@@ -1,149 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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

@@ -1,10 +0,0 @@
-import type { ComposedWithKey, tasks, WorkerCall } from "../types.js";
-export declare const createInlineExecutor: ({ tasks, genTaskID, batchSize, }: {
-    tasks: tasks | ComposedWithKey[];
-    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

@@ -1,282 +0,0 @@
-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 = Array.isArray(tasks)
-        ? tasks
-        : Object.values(tasks).sort((a, b) => a.id - b.id);
-    const runners = entries.map((entry) => {
-        // Imported tasks must never execute on the host inline lane: their module
-        // import is meant to stay inside the worker so worker permission policies
-        // apply. The pool already routes them to worker lanes, but guard here as
-        // defense in depth so a dispatch regression can't silently import on host.
-        if (entry.imported === true) {
-            return () => {
-                throw new Error("Imported task cannot run on the host inline lane");
-            };
-        }
-        return 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

@@ -1,30 +0,0 @@
-import { type ProcessSharedMemoryBacking } from "./process-worker.js";
-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";
-export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, }: {
-    list: string[];
-    ids: number[];
-    names: string[];
-    at: number[];
-    sab?: Sab;
-    thread: number;
-    debug?: DebugOptions;
-    hostDebug?: (message: string) => void;
-    totalNumberOfThread: number;
-    source?: string;
-    workerOptions?: WorkerSettings;
-    workerExecArgv?: string[];
-    permission?: WorkerData["permission"];
-    host?: DispatcherSettings;
-    payload?: PayloadBufferOptions;
-    bufferReferenceReturn?: "copy" | "borrow";
-    abortSignalCapacity?: number;
-    usesAbortSignal?: boolean;
-}) => WorkerContext & {
-    lock: ReturnType<typeof lock2>;
-    processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
-};
-export type CreateContext = WorkerContext;