knitting 0.1.63 → 0.1.73

package/src/runtime/pool.d.ts

@@ -2,28 +2,29 @@ import { createHostTxQueue } from "./tx-queue.js";
 import { type ProcessSharedMemoryBacking, type ProcessStealMemoryLayout, type ResolvedProcessSharedMemorySettings } from "./process-worker.js";
 import { type Sab } from "../ipc/transport/shared-memory.js";
 import { ChannelHandler, type DispatcherCheck } from "./dispatcher.js";
-import { lock2, type Task } from "../memory/lock.js";
+import type { DenoCompletionDoorbell } from "./deno-doorbell.js";
+import { lock2, type StealClaimDiscipline, type Task } from "../memory/lock.js";
 import "../memory/payloadCodec.js";
 import type { DebugOptions, DispatcherSettings, LockBuffers, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
 import "../worker/loop.js";
 import { type PayloadBufferOptions } from "../memory/payload-config.js";
+/** Build the shared submit and private return buffers for a stealing pool. */
+export declare const resolveStealRegionLanes: (consumers: number) => number;
 /**
- * Build the buffers, host-side locks and pending registry that a stealing pool
- * shares. One submit region for every worker to claim from, one private return
- * region per worker, and a single pool-global queue so a response arriving on
- * any lane settles the right promise.
- *
- * Region width follows paper §6.1: the largest power-of-two `g` leaving a spare
- * region for a delayed claimant (`slots / g >= consumers + 1`). At 32 slots that
- * caps how wide a region can be well before it caps the worker count.
+ * Return the widest region allowed by the selected claim discipline. Only
+ * Dekker needs a region per consumer; `ticket` has no regions at all and uses
+ * the width purely as a claim batch size.
  */
-export declare const resolveStealRegionLanes: (consumers: number) => number;
+export declare const resolveMaxStealRegionLanes: (consumers: number, stealClaim?: StealClaimDiscipline) => number;
 /** Maximum claimants that leave the protocol's required spare region. */
 export declare const MAX_STEAL_CONSUMERS: number;
-export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, abortSignalCapacity, usesAbortSignal, processWorker, }: {
+export declare const createStealPoolBuffers: ({ threads, payload, sharedArgs, regionLanes, stealClaim, abortSignalCapacity, usesAbortSignal, processWorker, }: {
     threads: number;
     payload?: PayloadBufferOptions;
+    /** Hand large arguments to workers as borrowed regions. See `unsafe.SharedArgs`. */
+    sharedArgs?: boolean;
     regionLanes?: number;
+    stealClaim?: StealClaimDiscipline;
     abortSignalCapacity?: number;
     usesAbortSignal?: boolean;
     processWorker?: {
@@ -53,6 +54,7 @@ export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, a
             activeRejectPlaceholder?: Task["reject"];
         }) => () => number;
         waitForHostChange: (timeoutMs?: number) => import("../memory/lock.js").WaitAsyncResult | undefined;
+        armHostNotifier: () => boolean;
         setHostWaiterArmed: (armed: boolean) => void;
         hasPendingFrames: () => boolean;
         getPendingFrameCount: () => number;
@@ -82,6 +84,7 @@ export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, a
             activeRejectPlaceholder?: Task["reject"];
         }) => () => number;
         waitForHostChange: (timeoutMs?: number) => import("../memory/lock.js").WaitAsyncResult | undefined;
+        armHostNotifier: () => boolean;
         setHostWaiterArmed: (armed: boolean) => void;
         hasPendingFrames: () => boolean;
         getPendingFrameCount: () => number;
@@ -92,24 +95,26 @@ export declare const createStealPoolBuffers: ({ threads, payload, regionLanes, a
         setPromiseHandler: (handler?: import("../memory/lock.js").PromisePayloadHandler) => void;
     }[];
     sharedQueue: {
-        rejectAll: (reason: string) => void;
+        close: (reason: unknown) => void;
+        rejectAll: (reason: unknown) => void;
         hasPendingFrames: () => boolean;
         txIdle: () => boolean;
         completeFrame: () => number;
         waitForCompletion: (onWake: () => void, timeoutMs?: number) => boolean;
+        armCompletionNotifier: () => boolean;
         setCompletionWaiterArmed: (armed: boolean) => void;
-        setReturnHooks: (lane: number, hooks: (import("../connections/buffer-reference.js").BufferReferenceReturnHooks | ((token: bigint) => void)) | undefined) => void;
         enqueue: (functionID: number, timeout?: import("../types.js").TaskTimeout, abortSignal?: import("../types.js").AbortSignalOption) => (rawArgs: unknown) => Promise<never> | import("../common/with-resolvers.js").PromiseWithMaybeReject<unknown>;
         flushToWorker: () => boolean;
         enqueueKnown: (task: Task) => boolean;
         settlePromisePayload: (task: Task, isRejected: boolean, value: unknown) => boolean;
     };
     regionLanes: number;
+    stealClaim: "dekker" | "ticket";
     processMemory: ProcessStealMemoryLayout;
     abortSignalSAB: SharedArrayBuffer | import("../types.js").SharedBufferRegion;
     abortSignalMax: number;
 };
-export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, hostDebug, totalNumberOfThread, workerCount, source, at, workerOptions, workerExecArgv, permission, host, payload, bufferReferenceReturn, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, stealPool, }: {
+export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, debugEpoch, hostDebug, totalNumberOfThread, workerCount, source, at, workerOptions, workerExecArgv, requestedExecArgv, permission, host, payload, sharedBytesEnabled, abortSignalCapacity, usesAbortSignal, sharedChannelHandler, denoCompletionDoorbell, stealPool, }: {
     list: string[];
     ids: number[];
     names: string[];
@@ -117,6 +122,7 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
     sab?: Sab;
     thread: number;
     debug?: DebugOptions;
+    debugEpoch?: number;
     hostDebug?: (message: string) => void;
     totalNumberOfThread: number;
     /**
@@ -128,10 +134,12 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
     source?: string;
     workerOptions?: WorkerSettings;
     workerExecArgv?: string[];
+    /** The caller's own `workerExecArgv`, before defaults and filtering. */
+    requestedExecArgv?: string[];
     permission?: WorkerData["permission"];
     host?: DispatcherSettings;
     payload?: PayloadBufferOptions;
-    bufferReferenceReturn?: "copy" | "borrow";
+    sharedBytesEnabled?: boolean;
     abortSignalCapacity?: number;
     usesAbortSignal?: boolean;
     /**
@@ -139,6 +147,8 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
      * macro channel that runs all lane checks.
      */
     sharedChannelHandler?: ChannelHandler;
+    /** Deno-only native callback shared by every thread worker in this pool. */
+    denoCompletionDoorbell?: DenoCompletionDoorbell;
     /**
      * Work-stealing wiring. When present the submit region, both host-side locks
      * and the pending registry are owned by `createPool` and shared: every worker
@@ -155,6 +165,7 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
         consumers: number;
         consumerId: number;
         regionLanes: number;
+        stealClaim?: StealClaimDiscipline;
         abortSignalSAB?: LockBuffers["headers"];
         abortSignalMax?: number;
         processMemory?: ProcessStealMemoryLayout;
@@ -168,6 +179,10 @@ export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug
     processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
     dispatcherCheck?: DispatcherCheck;
     laneWake?: () => void;
+    laneAwake?: () => boolean;
     bindSend?: (fn: () => void) => void;
+    bindCompletionWake?: (fn: () => void) => void;
+    processCompletionDoorbell?: boolean;
+    nodeCompletionDoorbell?: boolean;
 });
 export type CreateContext = WorkerContext;