knitting 0.1.46

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

@@ -0,0 +1,25 @@
+import { type Task, type Lock2 } from "../memory/lock.js";
+import type { AbortSignalOption, TaskTimeout } from "../types.js";
+import { type SignalAbortStore } from "../shared/abortSignal.js";
+type RawArguments = unknown;
+type FunctionID = number;
+type QueueTask = Task;
+export type MultiQueue = ReturnType<typeof createHostTxQueue>;
+type CreateHostTxQueueArgs = {
+    max?: number;
+    lock: Lock2;
+    returnLock: Lock2;
+    abortSignals?: Pick<SignalAbortStore, "getSignal" | "resetSignal" | "closeNow">;
+    now?: () => number;
+};
+export declare function createHostTxQueue({ max, lock, returnLock, abortSignals, now, }: CreateHostTxQueueArgs): {
+    rejectAll: (reason: string) => void;
+    hasPendingFrames: () => boolean;
+    txIdle: () => boolean;
+    completeFrame: () => number;
+    enqueue: (functionID: FunctionID, timeout?: TaskTimeout, abortSignal?: AbortSignalOption) => (rawArgs: RawArguments) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
+    flushToWorker: () => boolean;
+    enqueueKnown: (task: QueueTask) => boolean;
+    settlePromisePayload: (task: QueueTask, isRejected: boolean, value: unknown) => boolean;
+};
+export {};

package/src/runtime/tx-queue.js

@@ -0,0 +1,144 @@
+import { makeTask, resetTaskLocalFlags, TaskIndex, } from "../memory/lock.js";
+import { withResolvers } from "../common/with-resolvers.js";
+import { AbortSignalPoolExhausted, OneShotDeferred, } from "../shared/abortSignal.js";
+const SLOT_INDEX_MASK = 31;
+const SLOT_META_MASK = 0x07ffffff;
+const SLOT_META_SHIFT = 5;
+const FUNCTION_ID_MASK = 0xffff;
+const FUNCTION_META_MASK = 0xffff;
+const FUNCTION_META_SHIFT = 16;
+const ABORT_SIGNAL_META_OFFSET = 1;
+const NO_ABORT_SIGNAL = -1;
+const p_now = performance.now.bind(performance);
+export function createHostTxQueue({ max, lock, returnLock, abortSignals, now, }) {
+    const PLACE_HOLDER = (_) => {
+        throw ("UNREACHABLE FROM PLACE HOLDER (main)");
+    };
+    const newSlot = (id) => {
+        const task = makeTask();
+        task[TaskIndex.ID] = id;
+        task[TaskIndex.FunctionID] = 0;
+        task.value = null;
+        task.resolve = PLACE_HOLDER;
+        task.reject = PLACE_HOLDER;
+        return task;
+    };
+    const initialSize = max ?? 10;
+    const queue = Array.from({ length: initialSize }, (_, index) => newSlot(index));
+    const freeSockets = Array.from({ length: initialSize }, (_, i) => i);
+    // Local count
+    const freePush = (id) => freeSockets.push(id);
+    const freePop = () => freeSockets.pop();
+    const queuePush = (task) => queue.push(task);
+    const { publish, flushPending, hasPendingFrames, getPendingFrameCount, getPendingPromiseCount, resetPendingState, } = lock;
+    let inUsed = 0 | 0;
+    const resetSignal = abortSignals?.resetSignal;
+    const nowTime = now ?? p_now;
+    const resolveReturn = returnLock.resolveHost({
+        queue,
+        activeRejectPlaceholder: PLACE_HOLDER,
+        onResolved: (task) => {
+            inUsed = (inUsed - 1) | 0;
+            resetTaskLocalFlags(task);
+            task.value = null;
+            task.resolve = PLACE_HOLDER;
+            task.reject = PLACE_HOLDER;
+            freePush(task[TaskIndex.ID]);
+        },
+    });
+    // Helpers
+    const txIdle = () => getPendingFrameCount() === 0 && inUsed === getPendingPromiseCount();
+    const rejectAll = (reason) => {
+        for (let index = 0; index < queue.length; index++) {
+            const slot = queue[index];
+            if (slot.reject !== PLACE_HOLDER) {
+                try {
+                    slot.reject(reason);
+                }
+                catch {
+                }
+                slot.resolve = PLACE_HOLDER;
+                slot.reject = PLACE_HOLDER;
+                queue[index] = newSlot(index);
+            }
+        }
+        resetPendingState();
+        inUsed = 0 | 0;
+    };
+    const flushToWorker = () => flushPending();
+    const enqueueKnown = (task) => {
+        return publish(task);
+    };
+    return {
+        rejectAll,
+        hasPendingFrames,
+        txIdle,
+        completeFrame: resolveReturn,
+        enqueue: (functionID, timeout, abortSignal) => {
+            const HAS_TIMER = timeout !== undefined;
+            const functionIDMasked = functionID & FUNCTION_ID_MASK;
+            const USE_SIGNAL = abortSignal !== undefined && abortSignals !== undefined;
+            return (rawArgs) => {
+                // Expanding size if needed
+                if (inUsed === queue.length) {
+                    const newSize = inUsed + 32;
+                    let current = queue.length;
+                    while (newSize > current) {
+                        queuePush(newSlot(current));
+                        freePush(current);
+                        current++;
+                    }
+                }
+                const index = freePop();
+                const slot = queue[index];
+                const deferred = withResolvers();
+                slot[TaskIndex.FunctionID] = functionIDMasked;
+                if (USE_SIGNAL) {
+                    const maybeSignal = abortSignals.getSignal();
+                    if (maybeSignal === abortSignals.closeNow) {
+                        return Promise.reject(AbortSignalPoolExhausted);
+                    }
+                    new OneShotDeferred(deferred, () => resetSignal(maybeSignal));
+                    const encodedSignalMeta = ((maybeSignal + ABORT_SIGNAL_META_OFFSET) & FUNCTION_META_MASK) >>> 0;
+                    slot[TaskIndex.FunctionID] =
+                        ((encodedSignalMeta << FUNCTION_META_SHIFT) | functionIDMasked) >>> 0;
+                }
+                // Set info
+                slot.value = rawArgs;
+                slot[TaskIndex.ID] = index;
+                slot.resolve = deferred.resolve;
+                slot.reject = deferred.reject;
+                if (HAS_TIMER) {
+                    slot[TaskIndex.slotBuffer] =
+                        ((slot[TaskIndex.slotBuffer] & SLOT_INDEX_MASK) |
+                            ((((nowTime() >>> 0) & SLOT_META_MASK) << SLOT_META_SHIFT) >>> 0)) >>> 0;
+                }
+                void publish(slot);
+                inUsed = (inUsed + 1) | 0;
+                return deferred.promise;
+            };
+        },
+        flushToWorker,
+        enqueueKnown,
+        settlePromisePayload: (task, isRejected, value) => {
+            if (task.reject === PLACE_HOLDER)
+                return false;
+            if (isRejected) {
+                try {
+                    task.reject(value);
+                }
+                catch {
+                }
+                resetTaskLocalFlags(task);
+                task.value = null;
+                task.resolve = PLACE_HOLDER;
+                task.reject = PLACE_HOLDER;
+                inUsed = (inUsed - 1) | 0;
+                freePush(task[TaskIndex.ID]);
+                return false;
+            }
+            task.value = value;
+            return enqueueKnown(task);
+        },
+    };
+}

package/src/shared/abortSignal.d.ts

@@ -0,0 +1,23 @@
+import { withResolvers } from "../common/with-resolvers.js";
+import { type SharedBufferSource } from "../common/shared-buffer-region.js";
+export declare const AbortSignalPoolExhausted: unique symbol;
+export declare const EnqueuedAbortSignal: unique symbol;
+export type SignalAbortStore = ReturnType<typeof signalAbortFactory>;
+export type SetSignalResult = -1 | 0 | 1;
+export declare const signalAbortFactory: ({ sab, maxSignals, }: {
+    sab: SharedBufferSource;
+    maxSignals?: number;
+}) => {
+    max: number;
+    closeNow: number;
+    getSignal: () => number;
+    setSignal: (signal: number) => SetSignalResult;
+    abortAll: () => number;
+    hasAborted: (signal: number) => boolean;
+    resetSignal: (signal: number) => boolean;
+    inUseCount: () => number;
+};
+export declare class OneShotDeferred<T> {
+    #private;
+    constructor(deferred: ReturnType<typeof withResolvers<T>>, onSettle: () => void);
+}

package/src/shared/abortSignal.js

@@ -0,0 +1,126 @@
+import { toSharedBufferRegion, } from "../common/shared-buffer-region.js";
+const SLOT_BITS = 32;
+const SLOT_MASK = SLOT_BITS - 1;
+export const AbortSignalPoolExhausted = Symbol.for("knitting.abortSignal.poolExhausted");
+export const EnqueuedAbortSignal = Symbol.for("knitting.abortSignal.enqueuedSignal");
+export const signalAbortFactory = ({ sab, maxSignals, }) => {
+    const sabRegion = toSharedBufferRegion(sab);
+    const atomicView = new Uint32Array(sabRegion.sab, sabRegion.byteOffset, sabRegion.byteLength / Uint32Array.BYTES_PER_ELEMENT);
+    const size = atomicView.length;
+    const inUse = new Uint32Array(size);
+    const physicalMax = size * SLOT_BITS;
+    const max = (() => {
+        if (!Number.isFinite(maxSignals))
+            return physicalMax;
+        const parsed = Math.floor(maxSignals);
+        if (parsed <= 0)
+            return physicalMax;
+        return Math.min(parsed, physicalMax);
+    })();
+    const closeNow = max + 1;
+    let current = 0;
+    let cursor = 0;
+    const getSignal = () => {
+        if (current >= max)
+            return closeNow;
+        for (let step = 0; step < size; step++) {
+            const word = (cursor + step) % size;
+            const wordBase = word << 5;
+            const remaining = max - wordBase;
+            if (remaining <= 0)
+                continue;
+            const allowedMask = remaining >= SLOT_BITS
+                ? 0xFFFFFFFF
+                : ((1 << remaining) - 1) >>> 0;
+            const freeBits = ((~inUse[word]) & allowedMask) >>> 0;
+            if (freeBits === 0)
+                continue;
+            const bit = (freeBits & -freeBits) >>> 0;
+            inUse[word] = (inUse[word] | bit) >>> 0;
+            current = (current + 1) | 0;
+            cursor = (word + 1) % size;
+            // Recycled slot must start in "not aborted" state.
+            Atomics.and(atomicView, word, ~bit);
+            const bitIndex = 31 - Math.clz32(bit);
+            return (word << 5) + bitIndex;
+        }
+        return closeNow;
+    };
+    const setSignal = (signal) => {
+        // 0 => sentinel "abort because pool/size is exhausted"
+        if (signal === closeNow)
+            return 0;
+        // -1 => invalid signal id
+        if (!Number.isInteger(signal))
+            return -1;
+        if (signal < 0 || signal >= max)
+            return -1;
+        // 1 => signal bit was set as aborted
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        Atomics.or(atomicView, word, bit);
+        return 1;
+    };
+    const abortAll = () => {
+        for (let word = 0; word < size; word++) {
+            Atomics.store(atomicView, word, inUse[word]);
+        }
+        return current;
+    };
+    const hasAborted = (signal) => {
+        if (signal === closeNow)
+            return true;
+        if (!Number.isInteger(signal))
+            return false;
+        if (signal < 0 || signal >= max)
+            return false;
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        return (Atomics.load(atomicView, word) & bit) !== 0;
+    };
+    const resetSignal = (signal) => {
+        if (signal === closeNow)
+            return false;
+        if (!Number.isInteger(signal))
+            return false;
+        if (signal < 0 || signal >= max)
+            return false;
+        const word = signal >>> 5;
+        const bit = 1 << (signal & SLOT_MASK);
+        const used = (inUse[word] & bit) !== 0;
+        if (!used)
+            return false;
+        inUse[word] = (inUse[word] & ~bit) >>> 0;
+        if (current > 0)
+            current = (current - 1) | 0;
+        cursor = word;
+        // Clear aborted flag for future reuse.
+        Atomics.and(atomicView, word, ~bit);
+        return true;
+    };
+    return {
+        max,
+        closeNow,
+        getSignal,
+        setSignal,
+        abortAll,
+        hasAborted,
+        resetSignal,
+        inUseCount: () => current,
+    };
+};
+export class OneShotDeferred {
+    #triggered = false;
+    constructor(deferred, onSettle) {
+        const settleOnce = (fn) => (...args) => {
+            if (this.#triggered)
+                return;
+            this.#triggered = true;
+            onSettle();
+            fn(...args);
+        };
+        deferred.resolve = settleOnce(deferred.resolve);
+        deferred.reject = settleOnce(deferred.reject);
+        deferred.promise.reject = deferred.reject;
+    }
+}

package/src/types.d.ts

@@ -0,0 +1,283 @@
+import { endpointSymbol } from "./common/task-symbol.js";
+import type { Envelope } from "./common/envelope.js";
+import type { LockBufferTextCompat, SharedBufferTextCompat } from "./common/shared-buffer-text.js";
+import type { SharedBufferRegion, SharedBufferSource } from "./common/shared-buffer-region.js";
+import type { PayloadBufferMode, PayloadBufferOptions } from "./memory/payload-config.js";
+import type { PermissionProtocol, PermissionProtocolInput, ResolvedPermissionProtocol } from "./permission/protocol.js";
+type WorkerCall = {
+    fnNumber: number;
+    timeout?: TaskTimeout;
+    abortSignal?: AbortSignalOption;
+};
+type WorkerInvoke = (args: Uint8Array) => Promise<unknown>;
+interface WorkerContext {
+    txIdle(): boolean;
+    call(descriptor: WorkerCall): WorkerInvoke;
+    kills(): Promise<void>;
+}
+type CreateContext = WorkerContext;
+type WorkerData = {
+    sab: SharedBufferSource;
+    abortSignalSAB?: SharedBufferSource;
+    abortSignalMax?: number;
+    list: string[];
+    ids: number[];
+    thread: number;
+    totalNumberOfThread: number;
+    debug?: DebugOptions;
+    startAt: number;
+    workerOptions?: WorkerSettings;
+    at: number[];
+    lock: LockBuffers;
+    returnLock: LockBuffers;
+    payloadConfig?: PayloadBufferOptions;
+    permission?: ResolvedPermissionProtocol;
+};
+type LockBuffers = {
+    headers: SharedBufferSource;
+    headerSlotStrideU32?: number;
+    lockSector: SharedBufferSource;
+    payload: SharedBufferSource;
+    payloadSector: SharedBufferSource;
+    textCompat?: LockBufferTextCompat;
+};
+type JSONValue = string | number | boolean | null | JSONArray | JSONObject;
+interface JSONObject {
+    [key: string]: JSONValue;
+}
+interface JSONArray extends Array<JSONValue> {
+}
+type Serializable = string | object | number | boolean | bigint;
+type ValidInput = bigint | void | JSONValue | symbol | ArrayBuffer | Uint8Array | Int32Array | Float64Array | BigInt64Array | BigUint64Array | DataView | Error | Date | Envelope;
+type Args = ValidInput | Serializable;
+type MaybePromise<T> = T | Promise<T>;
+type NoBlob<T> = T extends Blob ? never : T;
+type TaskInput = NoBlob<Args> | Promise<NoBlob<Args>>;
+type TaskTimeout = number | {
+    time: number;
+    maybe?: true;
+    default?: unknown;
+    error?: unknown;
+};
+type BivariantCallback<Args extends unknown[], R> = {
+    bivarianceHack(...args: Args): R;
+}["bivarianceHack"];
+type AbortSignalConfig = {
+    readonly hasAborted: true;
+};
+type AbortSignalOption = true | AbortSignalConfig | undefined;
+type AbortSignalMethods<AS extends AbortSignalOption> = AS extends undefined ? never : {
+    hasAborted: () => boolean;
+};
+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>>>;
+type PromiseWithMaybeReject<T> = Promise<T> & {
+    reject: (reason?: unknown) => void;
+};
+type TaskLike<AS extends AbortSignalOption = AbortSignalOption> = {
+    readonly f: (...args: any[]) => any;
+} & (AS extends undefined ? {
+    readonly abortSignal?: undefined;
+} : {
+    readonly abortSignal: AS;
+});
+type Composed<A extends TaskInput = Args, B extends Args = Args, AS extends AbortSignalOption = undefined> = FixPoint<A, B, AS> & SecondPart;
+type tasks = Record<string, Composed<any, any, AbortSignalOption>>;
+type ComposedWithKey = Composed<any, any, AbortSignalOption> & {
+    name: string;
+};
+type PromiseWrapped<F extends (...args: any[]) => any, AS extends AbortSignalOption = undefined> = (...args: PromisifyCallArgs<F, AS>) => (AS extends undefined ? Promise<Awaited<ReturnType<F>>> : PromiseWithMaybeReject<Awaited<ReturnType<F>>>);
+type PromiseInput<T> = T | Promise<T>;
+type PromisifyArgs<T extends unknown[]> = {
+    [K in keyof T]: PromiseInput<T[K]>;
+};
+type NormalizeUndefinedSingleArg<T extends unknown[]> = T extends [undefined] ? [] | [undefined] : T;
+type AbortAwareCallArgs<T extends unknown[]> = T extends [...infer Head, AbortSignalToolkit<any>] ? NormalizeUndefinedSingleArg<Head> : NormalizeUndefinedSingleArg<T>;
+type HostCallArgs<F extends (...args: any[]) => any, AS extends AbortSignalOption> = AS extends undefined ? Parameters<F> : AbortAwareCallArgs<Parameters<F>>;
+type PromisifyCallArgs<F extends (...args: any[]) => any, AS extends AbortSignalOption> = HostCallArgs<F, AS> extends infer T ? T extends unknown[] ? PromisifyArgs<T> : never : never;
+type AbortSignalOfTask<T extends TaskLike<any>> = T extends {
+    readonly abortSignal: infer AS;
+} ? Extract<AS, AbortSignalOption> : undefined;
+type FunctionMapType<T extends Record<string, TaskLike<any>>> = {
+    [K in keyof T]: PromiseWrapped<T[K]["f"], AbortSignalOfTask<T[K]>>;
+};
+interface FixPointBase<A extends TaskInput, B extends Args, AS extends AbortSignalOption = undefined> {
+    readonly f: TaskFn<A, B, AS>;
+    readonly timeout?: TaskTimeout;
+}
+type FixPoint<A extends TaskInput, B extends Args, AS extends AbortSignalOption = undefined> = FixPointBase<A, B, AS> & (AS extends undefined ? {
+    readonly abortSignal?: undefined;
+} : {
+    readonly abortSignal: AS;
+});
+type ImportTaskOptions<A extends TaskInput = void, B extends Args = void, AS extends AbortSignalOption = undefined> = Omit<FixPoint<A, B, AS>, "f"> & {
+    readonly href: string;
+    readonly name?: string;
+};
+type SecondPart = {
+    readonly [endpointSymbol]: true;
+    readonly id: number;
+    /**
+     * IMPORTANT: `at` helps to create a `createPool` because we dont know
+     * the name of the variable at runtime, so basically this gets the logical order
+     * of the exported file, so no matter the name the worker can track which ` task `
+     * to track
+     */
+    readonly at: number;
+    readonly importedFrom: string;
+};
+type SingleTaskPool<A extends TaskInput = Args, B extends Args = Args, AS extends AbortSignalOption = undefined> = {
+    call: PromiseWrapped<TaskFn<A, B, AS>, AS>;
+    shutdown: (delayMs?: number) => Promise<void>;
+};
+type Pool<T extends Record<string, TaskLike<any>>> = {
+    shutdown: (delayMs?: number) => Promise<void>;
+    call: FunctionMapType<T>;
+};
+type ReturnFixed<A extends TaskInput = undefined, B extends Args = undefined, AS extends AbortSignalOption = undefined> = FixPoint<A, B, AS> & SecondPart & {
+    createPool: (options?: CreatePool) => SingleTaskPool<A, B, AS>;
+};
+type External = unknown;
+type Inliner = {
+    position?: "first" | "last";
+    /**
+     * Inline tasks per event loop tick.
+     * Defaults to 1 when inliner is enabled.
+     */
+    batchSize?: number;
+    /**
+     * Minimum in-flight calls before routing can use the inline host lane.
+     * Defaults to 1 (inline lane available immediately).
+     */
+    dispatchThreshold?: number;
+};
+type BalancerStrategy = "roundRobin" | "robinRound" | "firstIdle" | "randomLane" | "firstIdleOrRandom";
+type Balancer = BalancerStrategy | {
+    /**
+     * Optional. Defaults to "roundRobin".
+     */
+    strategy?: BalancerStrategy;
+};
+type DebugOptions = {
+    extras?: boolean;
+    logMain?: boolean;
+    logHref?: boolean;
+    logImportedUrl?: boolean;
+};
+type WorkerSettings = {
+    resolveAfterFinishingAll?: true;
+    /**
+     * Experimental worker runtime.
+     * "thread" uses Worker/worker_threads. "process" spawns another JavaScript
+     * runtime and shares one inherited fd-backed memory mapping.
+     */
+    runtime?: "thread" | "process";
+    /**
+     * Runtime executable to use when runtime is "process". Defaults to "bun".
+     */
+    processRuntime?: "bun" | "deno" | "node";
+    /**
+     * Command argv to prepend before the process worker runtime command.
+     * Useful for wrappers such as systemd-run, cgexec, nice, or taskset.
+     *
+     * Example:
+     * ["systemd-run", "--scope", "-p", "MemoryMax=500M", "-p", "CPUQuota=25%"]
+     */
+    processCommandPrefix?: string[];
+    timers?: WorkerTimers;
+    /**
+     * Hard task execution timeout in milliseconds.
+     * When exceeded, the pool is force-shutdown to stop runaway CPU tasks.
+     */
+    hardTimeoutMs?: number;
+};
+type WorkerTimers = {
+    /**
+     * Busy-spin budget before parking (microseconds).
+     */
+    spinMicroseconds?: number;
+    /**
+     * Atomics.wait timeout when parked (milliseconds).
+     */
+    parkMs?: number;
+    /**
+     * Atomics.pause duration during spin (nanoseconds).
+     * Set to 0 (or less) to disable pause calls.
+     */
+    pauseNanoseconds?: number;
+};
+type DispatcherSettings = {
+    /**
+     * How many immediate notify loops before backoff kicks in.
+     */
+    stallFreeLoops?: number;
+    /**
+     * Max backoff delay (milliseconds).
+     */
+    maxBackoffMs?: number;
+};
+type CreatePool = {
+    threads?: number;
+    /**
+   * @deprecated Too risky with processes, need to rewrite or delete.
+   */
+    inliner?: Inliner;
+    balancer?: Balancer;
+    worker?: WorkerSettings;
+    /**
+     * Payload transport settings.
+     */
+    payload?: PayloadBufferOptions;
+    /**
+     * Initial payload SharedArrayBuffer size (bytes) per worker direction.
+     * Defaults to 4 MiB when growable SAB is available, otherwise defaults to
+     * `payloadMaxBytes`.
+     * @deprecated Use `payload.payloadInitialBytes`.
+     */
+    payloadInitialBytes?: number;
+    /**
+     * Maximum payload SharedArrayBuffer size (bytes) per worker direction.
+     * Defaults to 64 MiB.
+     * @deprecated Use `payload.payloadMaxByteLength`.
+     */
+    payloadMaxBytes?: number;
+    /**
+     * @deprecated Use `payload.mode`.
+     */
+    bufferMode?: PayloadBufferMode;
+    /**
+     * @deprecated Use `payload.maxPayloadBytes`.
+     */
+    maxPayloadBytes?: number;
+    /**
+     * Abort-aware signal pool capacity.
+     * Defaults to `258`.
+     */
+    abortSignalCapacity?: number;
+    /**
+     * Host dispatcher backoff and scheduling options.
+     */
+    host?: DispatcherSettings;
+    /**
+     * Extra Node.js execArgv flags for worker threads (e.g. ["--expose-gc"]).
+     * Defaults to process.execArgv plus "--expose-gc" when allowed.
+     */
+    workerExecArgv?: string[];
+    /**
+     * Runtime permission protocol.
+     * Omit to use strict defaults with `allowImport: true`.
+     * Use `"strict"` (default for object mode) or `"unsafe"`.
+     * Accepts object form for fine-grained permission controls.
+     */
+    permission?: PermissionProtocolInput;
+    /**
+     * @deprecated Use `host` instead.
+     */
+    dispatcher?: DispatcherSettings;
+    debug?: DebugOptions;
+    source?: string;
+};
+export type { WorkerCall as WorkerCall, WorkerInvoke as WorkerInvoke, WorkerContext as WorkerContext, CreateContext as CreateContext, WorkerData as WorkerData, LockBuffers as LockBuffers, ValidInput as ValidInput, Args as Args, MaybePromise as MaybePromise, TaskInput as TaskInput, TaskTimeout as TaskTimeout, TaskFn as TaskFn, AbortSignalConfig as AbortSignalConfig, AbortSignalOption as AbortSignalOption, AbortSignalMethods as AbortSignalMethods, AbortSignalToolkit as AbortSignalToolkit, Composed as Composed, tasks as tasks, ComposedWithKey as ComposedWithKey, FunctionMapType as FunctionMapType, FixPoint as FixPoint, ImportTaskOptions as ImportTaskOptions, SecondPart as SecondPart, SingleTaskPool as SingleTaskPool, Pool as Pool, ReturnFixed as ReturnFixed, External as External, Inliner as Inliner, BalancerStrategy as BalancerStrategy, Balancer as Balancer, DebugOptions as DebugOptions, WorkerSettings as WorkerSettings, WorkerTimers as WorkerTimers, DispatcherSettings as DispatcherSettings, CreatePool as CreatePool, PayloadBufferMode as PayloadBufferMode, PayloadBufferOptions as PayloadBufferOptions, PermissionProtocol as PermissionProtocol, PermissionProtocolInput as PermissionProtocolInput, ResolvedPermissionProtocol as ResolvedPermissionProtocol, Envelope as Envelope, SharedBufferTextCompat as SharedBufferTextCompat, LockBufferTextCompat as LockBufferTextCompat, SharedBufferRegion as SharedBufferRegion, SharedBufferSource as SharedBufferSource, };
+export type { Task as Task } from "./memory/lock.js";
+export { LockBound as LockBound, PayloadBuffer as PayloadBuffer, PayloadSignal as PayloadSignal, TaskIndex as TaskIndex, } from "./memory/lock.js";
+export type { RegisterMalloc as RegisterMalloc } from "./memory/regionRegistry.js";

package/src/types.js

@@ -0,0 +1,2 @@
+import { endpointSymbol } from "./common/task-symbol.js";
+export { LockBound as LockBound, PayloadBuffer as PayloadBuffer, PayloadSignal as PayloadSignal, TaskIndex as TaskIndex, } from "./memory/lock.js";

package/src/worker/composable-runners.d.ts

@@ -0,0 +1,12 @@
+import { type Task } from "../memory/lock.js";
+import type { TimeoutSpec } from "./task-loader.js";
+type WorkerJob = (args: unknown, abortToolkit?: unknown) => unknown;
+type SlotRunner = (slot: Task) => unknown;
+type HasAborted = (signal: number) => boolean;
+export declare const composeWorkerRunner: ({ job, timeout, hasAborted, now, }: {
+    job: WorkerJob;
+    timeout?: TimeoutSpec;
+    hasAborted?: HasAborted;
+    now?: () => number;
+}) => SlotRunner;
+export {};