@math.gl/tasks 0.0.0-stage → 5.0.0-beta.11
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +147 -0
- package/LOADERS-GL-LICENSE.txt +52 -0
- package/README.md +26 -2
- package/THIRD-PARTY-NOTICES.md +5 -0
- package/dist/index.cjs +3454 -0
- package/dist/index.cjs.map +6 -0
- package/dist/index.d.ts +2 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +5 -0
- package/dist/index.js.map +1 -0
- package/dist/tasks/index.d.ts +9 -0
- package/dist/tasks/index.d.ts.map +1 -0
- package/dist/tasks/index.js +9 -0
- package/dist/tasks/index.js.map +1 -0
- package/dist/tasks/task-channel.d.ts +48 -0
- package/dist/tasks/task-channel.d.ts.map +1 -0
- package/dist/tasks/task-channel.js +166 -0
- package/dist/tasks/task-channel.js.map +1 -0
- package/dist/tasks/task-operation-queue.d.ts +26 -0
- package/dist/tasks/task-operation-queue.d.ts.map +1 -0
- package/dist/tasks/task-operation-queue.js +106 -0
- package/dist/tasks/task-operation-queue.js.map +1 -0
- package/dist/tasks/task-preload.d.ts +13 -0
- package/dist/tasks/task-preload.d.ts.map +1 -0
- package/dist/tasks/task-preload.js +96 -0
- package/dist/tasks/task-preload.js.map +1 -0
- package/dist/tasks/task-runner.d.ts +74 -0
- package/dist/tasks/task-runner.d.ts.map +1 -0
- package/dist/tasks/task-runner.js +811 -0
- package/dist/tasks/task-runner.js.map +1 -0
- package/dist/tasks/task-runtime.d.ts +27 -0
- package/dist/tasks/task-runtime.d.ts.map +1 -0
- package/dist/tasks/task-runtime.js +216 -0
- package/dist/tasks/task-runtime.js.map +1 -0
- package/dist/tasks/task-sync.d.ts +4 -0
- package/dist/tasks/task-sync.d.ts.map +1 -0
- package/dist/tasks/task-sync.js +95 -0
- package/dist/tasks/task-sync.js.map +1 -0
- package/dist/tasks/task-worker-channel.d.ts +11 -0
- package/dist/tasks/task-worker-channel.d.ts.map +1 -0
- package/dist/tasks/task-worker-channel.js +34 -0
- package/dist/tasks/task-worker-channel.js.map +1 -0
- package/dist/tasks/task.d.ts +132 -0
- package/dist/tasks/task.d.ts.map +1 -0
- package/dist/tasks/task.js +5 -0
- package/dist/tasks/task.js.map +1 -0
- package/dist/tasks/typed-task-dispatch.d.ts +30 -0
- package/dist/tasks/typed-task-dispatch.d.ts.map +1 -0
- package/dist/tasks/typed-task-dispatch.js +12 -0
- package/dist/tasks/typed-task-dispatch.js.map +1 -0
- package/dist/worker-utils/index.d.ts +25 -0
- package/dist/worker-utils/index.d.ts.map +1 -0
- package/dist/worker-utils/index.js +46 -0
- package/dist/worker-utils/index.js.map +1 -0
- package/dist/worker-utils/lib/async-queue/async-queue.d.ts +32 -0
- package/dist/worker-utils/lib/async-queue/async-queue.d.ts.map +1 -0
- package/dist/worker-utils/lib/async-queue/async-queue.js +88 -0
- package/dist/worker-utils/lib/async-queue/async-queue.js.map +1 -0
- package/dist/worker-utils/lib/env-utils/assert.d.ts +3 -0
- package/dist/worker-utils/lib/env-utils/assert.d.ts.map +1 -0
- package/dist/worker-utils/lib/env-utils/assert.js +13 -0
- package/dist/worker-utils/lib/env-utils/assert.js.map +1 -0
- package/dist/worker-utils/lib/env-utils/globals.d.ts +22 -0
- package/dist/worker-utils/lib/env-utils/globals.d.ts.map +1 -0
- package/dist/worker-utils/lib/env-utils/globals.js +30 -0
- package/dist/worker-utils/lib/env-utils/globals.js.map +1 -0
- package/dist/worker-utils/lib/env-utils/version.d.ts +3 -0
- package/dist/worker-utils/lib/env-utils/version.d.ts.map +1 -0
- package/dist/worker-utils/lib/env-utils/version.js +11 -0
- package/dist/worker-utils/lib/env-utils/version.js.map +1 -0
- package/dist/worker-utils/lib/library-utils/library-utils.d.ts +42 -0
- package/dist/worker-utils/lib/library-utils/library-utils.d.ts.map +1 -0
- package/dist/worker-utils/lib/library-utils/library-utils.js +251 -0
- package/dist/worker-utils/lib/library-utils/library-utils.js.map +1 -0
- package/dist/worker-utils/lib/node/worker_threads-browser.d.ts +15 -0
- package/dist/worker-utils/lib/node/worker_threads-browser.d.ts.map +1 -0
- package/dist/worker-utils/lib/node/worker_threads-browser.js +23 -0
- package/dist/worker-utils/lib/node/worker_threads-browser.js.map +1 -0
- package/dist/worker-utils/lib/node/worker_threads.d.ts +16 -0
- package/dist/worker-utils/lib/node/worker_threads.d.ts.map +1 -0
- package/dist/worker-utils/lib/node/worker_threads.js +7 -0
- package/dist/worker-utils/lib/node/worker_threads.js.map +1 -0
- package/dist/worker-utils/lib/npm-tag.d.ts +2 -0
- package/dist/worker-utils/lib/npm-tag.d.ts.map +1 -0
- package/dist/worker-utils/lib/npm-tag.js +5 -0
- package/dist/worker-utils/lib/npm-tag.js.map +1 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.browser.d.ts +8 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.browser.d.ts.map +1 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.browser.js +18 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.browser.js.map +1 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.d.ts +45 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.d.ts.map +1 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.js +128 -0
- package/dist/worker-utils/lib/process-utils/child-process-proxy.js.map +1 -0
- package/dist/worker-utils/lib/process-utils/process-utils.d.ts +2 -0
- package/dist/worker-utils/lib/process-utils/process-utils.d.ts.map +1 -0
- package/dist/worker-utils/lib/process-utils/process-utils.js +32 -0
- package/dist/worker-utils/lib/process-utils/process-utils.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/create-worker.d.ts +9 -0
- package/dist/worker-utils/lib/worker-api/create-worker.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/create-worker.js +229 -0
- package/dist/worker-utils/lib/worker-api/create-worker.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/get-worker-url.d.ts +29 -0
- package/dist/worker-utils/lib/worker-api/get-worker-url.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/get-worker-url.js +101 -0
- package/dist/worker-utils/lib/worker-api/get-worker-url.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/process-on-worker.d.ts +67 -0
- package/dist/worker-utils/lib/worker-api/process-on-worker.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/process-on-worker.js +429 -0
- package/dist/worker-utils/lib/worker-api/process-on-worker.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/shared-state.d.ts +34 -0
- package/dist/worker-utils/lib/worker-api/shared-state.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/shared-state.js +105 -0
- package/dist/worker-utils/lib/worker-api/shared-state.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/validate-output-ownership.d.ts +3 -0
- package/dist/worker-utils/lib/worker-api/validate-output-ownership.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/validate-output-ownership.js +10 -0
- package/dist/worker-utils/lib/worker-api/validate-output-ownership.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/validate-worker-version.d.ts +9 -0
- package/dist/worker-utils/lib/worker-api/validate-worker-version.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/validate-worker-version.js +35 -0
- package/dist/worker-utils/lib/worker-api/validate-worker-version.js.map +1 -0
- package/dist/worker-utils/lib/worker-api/worker-resource.d.ts +33 -0
- package/dist/worker-utils/lib/worker-api/worker-resource.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-api/worker-resource.js +156 -0
- package/dist/worker-utils/lib/worker-api/worker-resource.js.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-body.d.ts +20 -0
- package/dist/worker-utils/lib/worker-farm/worker-body.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-body.js +134 -0
- package/dist/worker-utils/lib/worker-farm/worker-body.js.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-farm.d.ts +73 -0
- package/dist/worker-utils/lib/worker-farm/worker-farm.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-farm.js +135 -0
- package/dist/worker-utils/lib/worker-farm/worker-farm.js.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-job.d.ts +47 -0
- package/dist/worker-utils/lib/worker-farm/worker-job.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-job.js +124 -0
- package/dist/worker-utils/lib/worker-farm/worker-job.js.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-pool.d.ts +152 -0
- package/dist/worker-utils/lib/worker-farm/worker-pool.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-pool.js +584 -0
- package/dist/worker-utils/lib/worker-farm/worker-pool.js.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-thread.d.ts +77 -0
- package/dist/worker-utils/lib/worker-farm/worker-thread.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-farm/worker-thread.js +215 -0
- package/dist/worker-utils/lib/worker-farm/worker-thread.js.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-input-byte-length.d.ts +5 -0
- package/dist/worker-utils/lib/worker-utils/get-input-byte-length.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-input-byte-length.js +39 -0
- package/dist/worker-utils/lib/worker-utils/get-input-byte-length.js.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.d.ts +15 -0
- package/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js +84 -0
- package/dist/worker-utils/lib/worker-utils/get-loadable-worker-url.js.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-transfer-list.d.ts +16 -0
- package/dist/worker-utils/lib/worker-utils/get-transfer-list.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-utils/get-transfer-list.js +127 -0
- package/dist/worker-utils/lib/worker-utils/get-transfer-list.js.map +1 -0
- package/dist/worker-utils/lib/worker-utils/remove-nontransferable-options.d.ts +6 -0
- package/dist/worker-utils/lib/worker-utils/remove-nontransferable-options.d.ts.map +1 -0
- package/dist/worker-utils/lib/worker-utils/remove-nontransferable-options.js +27 -0
- package/dist/worker-utils/lib/worker-utils/remove-nontransferable-options.js.map +1 -0
- package/dist/worker-utils/types.d.ts +165 -0
- package/dist/worker-utils/types.d.ts.map +1 -0
- package/dist/worker-utils/types.js +5 -0
- package/dist/worker-utils/types.js.map +1 -0
- package/dist/worker-utils/workers/null-worker.d.ts +2 -0
- package/dist/worker-utils/workers/null-worker.d.ts.map +1 -0
- package/dist/worker-utils/workers/null-worker.js +17 -0
- package/dist/worker-utils/workers/null-worker.js.map +1 -0
- package/package.json +43 -4
- package/src/index.ts +5 -0
- package/src/tasks/index.ts +33 -0
- package/src/tasks/task-channel.ts +191 -0
- package/src/tasks/task-operation-queue.ts +109 -0
- package/src/tasks/task-preload.ts +107 -0
- package/src/tasks/task-runner.ts +933 -0
- package/src/tasks/task-runtime.ts +244 -0
- package/src/tasks/task-sync.ts +100 -0
- package/src/tasks/task-worker-channel.ts +44 -0
- package/src/tasks/task.ts +168 -0
- package/src/tasks/typed-task-dispatch.ts +44 -0
- package/src/worker-utils/index.ts +105 -0
- package/src/worker-utils/lib/async-queue/async-queue.ts +100 -0
- package/src/worker-utils/lib/env-utils/assert.ts +14 -0
- package/src/worker-utils/lib/env-utils/globals.ts +40 -0
- package/src/worker-utils/lib/env-utils/version.ts +15 -0
- package/src/worker-utils/lib/library-utils/library-utils.ts +305 -0
- package/src/worker-utils/lib/node/worker_threads-browser.ts +44 -0
- package/src/worker-utils/lib/node/worker_threads.ts +21 -0
- package/src/worker-utils/lib/npm-tag.ts +5 -0
- package/src/worker-utils/lib/process-utils/child-process-proxy.browser.ts +23 -0
- package/src/worker-utils/lib/process-utils/child-process-proxy.ts +172 -0
- package/src/worker-utils/lib/process-utils/process-utils.ts +34 -0
- package/src/worker-utils/lib/worker-api/create-worker.ts +271 -0
- package/src/worker-utils/lib/worker-api/get-worker-url.ts +130 -0
- package/src/worker-utils/lib/worker-api/process-on-worker.ts +596 -0
- package/src/worker-utils/lib/worker-api/shared-state.ts +135 -0
- package/src/worker-utils/lib/worker-api/validate-output-ownership.ts +10 -0
- package/src/worker-utils/lib/worker-api/validate-worker-version.ts +44 -0
- package/src/worker-utils/lib/worker-api/worker-resource.ts +203 -0
- package/src/worker-utils/lib/worker-farm/worker-body.ts +154 -0
- package/src/worker-utils/lib/worker-farm/worker-farm.ts +172 -0
- package/src/worker-utils/lib/worker-farm/worker-job.ts +148 -0
- package/src/worker-utils/lib/worker-farm/worker-pool.ts +719 -0
- package/src/worker-utils/lib/worker-farm/worker-thread.ts +260 -0
- package/src/worker-utils/lib/worker-utils/get-input-byte-length.ts +34 -0
- package/src/worker-utils/lib/worker-utils/get-loadable-worker-url.ts +96 -0
- package/src/worker-utils/lib/worker-utils/get-transfer-list.ts +125 -0
- package/src/worker-utils/lib/worker-utils/remove-nontransferable-options.ts +27 -0
- package/src/worker-utils/types.ts +224 -0
- package/src/worker-utils/workers/null-worker.ts +20 -0
|
@@ -0,0 +1,933 @@
|
|
|
1
|
+
// math.gl
|
|
2
|
+
// SPDX-License-Identifier: MIT
|
|
3
|
+
// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
|
|
4
|
+
/// <reference lib="es2021.promise" />
|
|
5
|
+
|
|
6
|
+
import {
|
|
7
|
+
WorkerPool,
|
|
8
|
+
getTransferList,
|
|
9
|
+
processOnWorker,
|
|
10
|
+
processOnWorkerInBatches,
|
|
11
|
+
type WorkerObject,
|
|
12
|
+
type ProcessOnWorkerOptions
|
|
13
|
+
} from '../worker-utils/index';
|
|
14
|
+
import {TaskRuntime, assertPayload, clonePayload, localContext} from './task-runtime';
|
|
15
|
+
import {runTaskSync} from './task-sync';
|
|
16
|
+
import {TaskOperationQueue} from './task-operation-queue';
|
|
17
|
+
import {TaskWorkerChannel} from './task-worker-channel';
|
|
18
|
+
import {TaskRequestError} from './task-channel';
|
|
19
|
+
import type {
|
|
20
|
+
AnyTask,
|
|
21
|
+
TaskInput,
|
|
22
|
+
TaskOutput,
|
|
23
|
+
TaskBatchInput,
|
|
24
|
+
TaskBatchOutput,
|
|
25
|
+
Initialization,
|
|
26
|
+
TaskRunControls,
|
|
27
|
+
TaskInitializeControls,
|
|
28
|
+
TaskRunOptions,
|
|
29
|
+
TaskBatchRunOptions,
|
|
30
|
+
TaskRunsOptions,
|
|
31
|
+
InitializedTaskOptions,
|
|
32
|
+
InitializedTaskCallOptions,
|
|
33
|
+
InitializedTaskBatchOptions,
|
|
34
|
+
RequestArgs,
|
|
35
|
+
TaskRunnerOptions,
|
|
36
|
+
SynchronousTask,
|
|
37
|
+
TaskSyncRunOptions
|
|
38
|
+
} from './task';
|
|
39
|
+
|
|
40
|
+
/** A state instance bound to one execution location, serialized unless explicitly opted in. */
|
|
41
|
+
export class InitializedTask<D extends AnyTask> {
|
|
42
|
+
private runtime: TaskRuntime;
|
|
43
|
+
private pool?: WorkerPool;
|
|
44
|
+
private workerChannel?: TaskWorkerChannel;
|
|
45
|
+
private channelInputs?: AsyncIterator<object>;
|
|
46
|
+
private nextProgressId = 1;
|
|
47
|
+
private progressCallbacks = new Map<number, TaskRunControls['onProgress']>();
|
|
48
|
+
private streamProgress?: TaskRunControls['onProgress'];
|
|
49
|
+
private streamProgressId?: number;
|
|
50
|
+
private callbackFailures = new Map<number, {reason: unknown}>();
|
|
51
|
+
private descriptor?: WorkerObject;
|
|
52
|
+
private readonly operationQueue: TaskOperationQueue;
|
|
53
|
+
private closing?: Promise<void>;
|
|
54
|
+
private closed = false;
|
|
55
|
+
private finalized = false;
|
|
56
|
+
private streams = new Set<() => Promise<void>>();
|
|
57
|
+
private invalid = false;
|
|
58
|
+
private readonly concurrent: boolean;
|
|
59
|
+
private controller = new AbortController();
|
|
60
|
+
|
|
61
|
+
/** @internal Use TaskRunner.initializeTask. */
|
|
62
|
+
constructor(
|
|
63
|
+
private task: D,
|
|
64
|
+
private release: () => void,
|
|
65
|
+
private readonly initializationControls: TaskInitializeControls
|
|
66
|
+
) {
|
|
67
|
+
const controls = initializationControls;
|
|
68
|
+
this.runtime = new TaskRuntime(task);
|
|
69
|
+
const concurrency = controls.operationConcurrency ?? 1;
|
|
70
|
+
const maximum = task.concurrency?.maxConcurrency ?? 1;
|
|
71
|
+
if (
|
|
72
|
+
!Number.isSafeInteger(maximum) ||
|
|
73
|
+
maximum < 1 ||
|
|
74
|
+
!Number.isSafeInteger(concurrency) ||
|
|
75
|
+
concurrency < 1 ||
|
|
76
|
+
concurrency > maximum
|
|
77
|
+
) {
|
|
78
|
+
throw new RangeError('Task concurrency must be between 1 and the task maximum');
|
|
79
|
+
}
|
|
80
|
+
this.operationQueue = new TaskOperationQueue(concurrency);
|
|
81
|
+
this.concurrent = concurrency > 1;
|
|
82
|
+
const execution = controls.execution ?? 'auto';
|
|
83
|
+
if (!['auto', 'main-thread', 'worker'].includes(execution))
|
|
84
|
+
throw new TypeError('Invalid execution mode');
|
|
85
|
+
if (execution === 'worker' && !task.worker) throw new Error('Task has no worker');
|
|
86
|
+
if (execution !== 'main-thread' && task.worker) {
|
|
87
|
+
const target = task.worker;
|
|
88
|
+
if (Boolean(target.url) === Boolean(target.create))
|
|
89
|
+
throw new Error('Supply exactly one worker URL or factory');
|
|
90
|
+
if (this.concurrent || controls.onRequest || controls.onEvent) {
|
|
91
|
+
this.workerChannel = new TaskWorkerChannel(task.id, target, {
|
|
92
|
+
handleRequest: async (operation, payload, signal) => {
|
|
93
|
+
if (operation === 'task:next-input') {
|
|
94
|
+
if (!this.channelInputs) throw new Error('No active task stream');
|
|
95
|
+
return this.channelInputs.next();
|
|
96
|
+
}
|
|
97
|
+
if (!controls.onRequest) throw new Error('No host request handler configured');
|
|
98
|
+
const request = payload as {operation: string; payload: unknown};
|
|
99
|
+
if (operation !== 'task:host-request') throw new Error('Unknown host request');
|
|
100
|
+
return controls.onRequest(request.operation, request.payload, signal);
|
|
101
|
+
},
|
|
102
|
+
getResultTransferList: (value, request) =>
|
|
103
|
+
(request as {outputOwnership?: string}).outputOwnership === 'transfer'
|
|
104
|
+
? getTransferList(value)
|
|
105
|
+
: [],
|
|
106
|
+
handleEvent: (operation, payload) => {
|
|
107
|
+
const {id} = payload as {id: number};
|
|
108
|
+
try {
|
|
109
|
+
if (operation === 'task:progress') {
|
|
110
|
+
const event = payload as {
|
|
111
|
+
id: number;
|
|
112
|
+
progress: Parameters<NonNullable<TaskRunControls['onProgress']>>[0];
|
|
113
|
+
};
|
|
114
|
+
(this.progressCallbacks.get(event.id) ?? this.streamProgress)?.(event.progress);
|
|
115
|
+
} else if (operation === 'task:host-event') {
|
|
116
|
+
const event = payload as {operation: string; payload: unknown};
|
|
117
|
+
controls.onEvent?.(event.operation, event.payload);
|
|
118
|
+
}
|
|
119
|
+
} catch (reason) {
|
|
120
|
+
// Let remote work settle: a host notification failure must not
|
|
121
|
+
// interrupt shared state or unrelated concurrent operations.
|
|
122
|
+
if (this.progressCallbacks.has(id) || this.streamProgressId === id) {
|
|
123
|
+
if (!this.callbackFailures.has(id)) this.callbackFailures.set(id, {reason});
|
|
124
|
+
}
|
|
125
|
+
}
|
|
126
|
+
},
|
|
127
|
+
onFailure: reason => {
|
|
128
|
+
this.invalid = true;
|
|
129
|
+
this.operationQueue.cancelPending(reason);
|
|
130
|
+
this.controller.abort(reason);
|
|
131
|
+
}
|
|
132
|
+
});
|
|
133
|
+
return;
|
|
134
|
+
}
|
|
135
|
+
this.pool = new WorkerPool({
|
|
136
|
+
name: task.id,
|
|
137
|
+
url: target.url?.toString(),
|
|
138
|
+
loadWorker: target.create,
|
|
139
|
+
workerType: 'module',
|
|
140
|
+
maxConcurrency: 1,
|
|
141
|
+
maxMobileConcurrency: 1
|
|
142
|
+
});
|
|
143
|
+
this.descriptor = {
|
|
144
|
+
id: task.id,
|
|
145
|
+
name: task.id,
|
|
146
|
+
module: 'tasks',
|
|
147
|
+
version: 'prototype',
|
|
148
|
+
options: {},
|
|
149
|
+
worker: target.url?.toString() ?? true,
|
|
150
|
+
loadWorker: target.create,
|
|
151
|
+
workerInBatches: target.capabilities.streaming
|
|
152
|
+
};
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
/** @internal */
|
|
157
|
+
async initialize(input: object, controls: TaskRunControls): Promise<void> {
|
|
158
|
+
try {
|
|
159
|
+
assertPayload(input);
|
|
160
|
+
await this.enqueue(() => this.invoke('initialize', input, {}, controls));
|
|
161
|
+
} catch (error) {
|
|
162
|
+
await this.terminate(error);
|
|
163
|
+
throw error;
|
|
164
|
+
}
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
runTask(
|
|
168
|
+
input: TaskInput<D>,
|
|
169
|
+
...args: RequestArgs<InitializedTaskCallOptions<D>>
|
|
170
|
+
): Promise<TaskOutput<D>> {
|
|
171
|
+
if (this.invalid)
|
|
172
|
+
return Promise.reject(new Error('Initialized task is invalid; initialize a new instance'));
|
|
173
|
+
if (this.closed) return Promise.reject(new Error('Initialized task is closed'));
|
|
174
|
+
const timeout = args[0]?.timeout;
|
|
175
|
+
if (
|
|
176
|
+
timeout !== undefined &&
|
|
177
|
+
(!Number.isSafeInteger(timeout) || timeout < 0 || timeout > 4294967295)
|
|
178
|
+
) {
|
|
179
|
+
return Promise.reject(new RangeError('Invalid task timeout'));
|
|
180
|
+
}
|
|
181
|
+
const deadline = timeout === undefined ? undefined : AbortSignal.timeout(timeout);
|
|
182
|
+
const signal =
|
|
183
|
+
deadline && args[0]?.signal
|
|
184
|
+
? AbortSignal.any([deadline, args[0].signal])
|
|
185
|
+
: (deadline ?? args[0]?.signal);
|
|
186
|
+
const controls = {...args[0], signal};
|
|
187
|
+
const mode = this.task.concurrency?.getSchedulingMode?.(input) ?? 'exclusive';
|
|
188
|
+
return this.operationQueue.run(
|
|
189
|
+
mode,
|
|
190
|
+
async () => {
|
|
191
|
+
signal?.throwIfAborted();
|
|
192
|
+
this.checkCapability('atomic');
|
|
193
|
+
const invalidate = () => {
|
|
194
|
+
if (this.concurrent) {
|
|
195
|
+
this.invalid = true;
|
|
196
|
+
this.operationQueue.cancelPending(signal?.reason);
|
|
197
|
+
this.controller.abort(signal?.reason);
|
|
198
|
+
}
|
|
199
|
+
};
|
|
200
|
+
signal?.addEventListener('abort', invalidate, {once: true});
|
|
201
|
+
try {
|
|
202
|
+
return await this.invoke('process', input, (args[0] as any)?.options ?? {}, controls);
|
|
203
|
+
} finally {
|
|
204
|
+
signal?.removeEventListener('abort', invalidate);
|
|
205
|
+
}
|
|
206
|
+
},
|
|
207
|
+
signal
|
|
208
|
+
) as Promise<TaskOutput<D>>;
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
/** Independent calls sharing this instance, always serial and in input order. */
|
|
212
|
+
runTasks(
|
|
213
|
+
inputs: Iterable<TaskInput<D>> | AsyncIterable<TaskInput<D>>,
|
|
214
|
+
...args: RequestArgs<InitializedTaskOptions<D>>
|
|
215
|
+
): AsyncIterable<TaskOutput<D>> {
|
|
216
|
+
return this.serialStream(async function* (self) {
|
|
217
|
+
self.checkCapability('atomic');
|
|
218
|
+
for await (const input of asAsync(inputs, self.controls(args[0]).signal)) {
|
|
219
|
+
yield await self.invoke('process', input, (args[0] as any)?.options ?? {}, args[0]);
|
|
220
|
+
}
|
|
221
|
+
}, args[0]?.signal);
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
/** One processor invocation for the entire input iterable. */
|
|
225
|
+
runTaskInBatches(
|
|
226
|
+
inputs: Iterable<TaskBatchInput<D>> | AsyncIterable<TaskBatchInput<D>>,
|
|
227
|
+
...args: RequestArgs<InitializedTaskBatchOptions<D>>
|
|
228
|
+
): AsyncIterable<TaskBatchOutput<D>> {
|
|
229
|
+
return this.serialStream(async function* (self) {
|
|
230
|
+
self.checkCapability('streaming');
|
|
231
|
+
const controls = self.controls(args[0]);
|
|
232
|
+
const options = clonePayload((args[0] as any)?.options ?? {});
|
|
233
|
+
async function* prepared() {
|
|
234
|
+
for await (const input of asAsync(inputs, controls.signal)) {
|
|
235
|
+
controls.signal?.throwIfAborted();
|
|
236
|
+
assertNoTransferAlias(input, (args[0] as any)?.options ?? {}, controls.inputOwnership);
|
|
237
|
+
yield clonePayload(input, controls.inputOwnership);
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
let completed = false;
|
|
241
|
+
try {
|
|
242
|
+
if (self.workerChannel) {
|
|
243
|
+
self.channelInputs = prepared()[Symbol.asyncIterator]();
|
|
244
|
+
self.streamProgress = controls.onProgress;
|
|
245
|
+
try {
|
|
246
|
+
await self.invoke('stream-open', {}, options, controls);
|
|
247
|
+
while (true) {
|
|
248
|
+
const result = await self.invoke('stream-next', {}, {}, controls);
|
|
249
|
+
if (result.done) break;
|
|
250
|
+
yield result.value;
|
|
251
|
+
}
|
|
252
|
+
} finally {
|
|
253
|
+
try {
|
|
254
|
+
if (!self.invalid) await self.invoke('stream-close', {}, {}, controls);
|
|
255
|
+
} finally {
|
|
256
|
+
await self.channelInputs.return?.();
|
|
257
|
+
self.channelInputs = undefined;
|
|
258
|
+
self.streamProgress = undefined;
|
|
259
|
+
if (self.streamProgressId !== undefined)
|
|
260
|
+
self.callbackFailures.delete(self.streamProgressId);
|
|
261
|
+
self.streamProgressId = undefined;
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
} else if (self.pool) {
|
|
265
|
+
await self.invoke('stream-options', {}, options, controls);
|
|
266
|
+
yield* processOnWorkerInBatches(self.descriptor!, prepared(), {
|
|
267
|
+
...self.workerOptions(controls),
|
|
268
|
+
inputOwnership: 'transfer',
|
|
269
|
+
workerInBatches: true
|
|
270
|
+
});
|
|
271
|
+
} else {
|
|
272
|
+
for await (const output of self.runtime.stream(
|
|
273
|
+
prepared(),
|
|
274
|
+
options,
|
|
275
|
+
self.runtimeContext(controls)
|
|
276
|
+
)) {
|
|
277
|
+
controls.signal?.throwIfAborted();
|
|
278
|
+
yield clonePayload(output, controls.outputOwnership ?? 'transfer');
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
completed = true;
|
|
282
|
+
} catch (error) {
|
|
283
|
+
if (self.workerChannel) {
|
|
284
|
+
self.invalid = true;
|
|
285
|
+
self.operationQueue.cancelPending(error);
|
|
286
|
+
self.controller.abort(error);
|
|
287
|
+
await self.workerChannel.destroy(error);
|
|
288
|
+
}
|
|
289
|
+
if (self.pool) {
|
|
290
|
+
self.invalid = true;
|
|
291
|
+
await self.pool.destroy(error);
|
|
292
|
+
}
|
|
293
|
+
throw error;
|
|
294
|
+
} finally {
|
|
295
|
+
// Legacy stream cancellation may terminate the pinned worker. Never reuse
|
|
296
|
+
// an incarnation after ending a worker stream without a success handshake.
|
|
297
|
+
if (self.pool && !completed) self.invalid = true;
|
|
298
|
+
if (self.workerChannel && !completed && !self.invalid) {
|
|
299
|
+
const reason = new Error('Worker stream ended before completion');
|
|
300
|
+
self.invalid = true;
|
|
301
|
+
self.operationQueue.cancelPending(reason);
|
|
302
|
+
self.controller.abort(reason);
|
|
303
|
+
await self.workerChannel.destroy(reason);
|
|
304
|
+
}
|
|
305
|
+
}
|
|
306
|
+
}, args[0]?.signal);
|
|
307
|
+
}
|
|
308
|
+
|
|
309
|
+
/** Lifecycle status of this initialized task. */
|
|
310
|
+
get state(): 'ready' | 'closing' | 'closed' | 'invalid' {
|
|
311
|
+
if (this.invalid) return 'invalid';
|
|
312
|
+
if (this.finalized) return 'closed';
|
|
313
|
+
return this.closed ? 'closing' : 'ready';
|
|
314
|
+
}
|
|
315
|
+
|
|
316
|
+
/** Drain accepted work, invoke destroy, and release execution capacity. */
|
|
317
|
+
close(): Promise<void> {
|
|
318
|
+
if (!this.closing) {
|
|
319
|
+
this.closed = true;
|
|
320
|
+
this.closing = (async () => {
|
|
321
|
+
try {
|
|
322
|
+
await this.operationQueue.close();
|
|
323
|
+
if (!this.invalid) await this.invoke('destroy', {}, {});
|
|
324
|
+
else if (!this.pool && !this.workerChannel) await this.runtime.destroy();
|
|
325
|
+
} finally {
|
|
326
|
+
try {
|
|
327
|
+
await this.pool?.destroy();
|
|
328
|
+
await this.workerChannel?.destroy();
|
|
329
|
+
} finally {
|
|
330
|
+
this.finalized = true;
|
|
331
|
+
this.release();
|
|
332
|
+
}
|
|
333
|
+
}
|
|
334
|
+
})();
|
|
335
|
+
}
|
|
336
|
+
return this.closing;
|
|
337
|
+
}
|
|
338
|
+
|
|
339
|
+
/** Abort work. Local JavaScript must settle before its state can be destroyed. */
|
|
340
|
+
async terminate(reason: unknown = new Error('Task terminated')): Promise<void> {
|
|
341
|
+
this.operationQueue.cancelPending(reason);
|
|
342
|
+
this.controller.abort(reason);
|
|
343
|
+
if (this.workerChannel) {
|
|
344
|
+
this.invalid = true;
|
|
345
|
+
await this.workerChannel.destroy(reason);
|
|
346
|
+
}
|
|
347
|
+
if (this.pool) {
|
|
348
|
+
this.invalid = true;
|
|
349
|
+
await this.pool.destroy(reason);
|
|
350
|
+
}
|
|
351
|
+
await Promise.allSettled([...this.streams].map(stop => stop()));
|
|
352
|
+
await this.close();
|
|
353
|
+
}
|
|
354
|
+
|
|
355
|
+
private checkCapability(kind: 'atomic' | 'streaming'): void {
|
|
356
|
+
if (
|
|
357
|
+
this.pool || this.workerChannel
|
|
358
|
+
? !this.task.worker?.capabilities[kind]
|
|
359
|
+
: !(kind === 'atomic' ? this.task.process : this.task.processInBatches)
|
|
360
|
+
) {
|
|
361
|
+
throw new Error(`Task has no ${kind} processor for this execution route`);
|
|
362
|
+
}
|
|
363
|
+
}
|
|
364
|
+
|
|
365
|
+
private controls(controls: TaskRunControls = {}): TaskRunControls {
|
|
366
|
+
if (controls.outputOwnership && !['copy', 'transfer'].includes(controls.outputOwnership))
|
|
367
|
+
throw new TypeError('Invalid output ownership');
|
|
368
|
+
return {
|
|
369
|
+
...controls,
|
|
370
|
+
signal: controls.signal
|
|
371
|
+
? AbortSignal.any([controls.signal, this.controller.signal])
|
|
372
|
+
: this.controller.signal
|
|
373
|
+
};
|
|
374
|
+
}
|
|
375
|
+
|
|
376
|
+
private workerOptions(controls: TaskRunControls): ProcessOnWorkerOptions {
|
|
377
|
+
return {
|
|
378
|
+
workerPool: this.pool,
|
|
379
|
+
workerType: 'module',
|
|
380
|
+
inputOwnership: controls.inputOwnership ?? 'copy',
|
|
381
|
+
outputOwnership: controls.outputOwnership ?? 'transfer',
|
|
382
|
+
signal: controls.signal,
|
|
383
|
+
onProgress: controls.onProgress,
|
|
384
|
+
cancellationMode: 'terminate'
|
|
385
|
+
};
|
|
386
|
+
}
|
|
387
|
+
|
|
388
|
+
private async invoke(
|
|
389
|
+
operation: string,
|
|
390
|
+
input: any,
|
|
391
|
+
options: object,
|
|
392
|
+
controls: TaskRunControls = {}
|
|
393
|
+
): Promise<any> {
|
|
394
|
+
if (this.invalid) throw new Error('Initialized task is invalid; initialize a new instance');
|
|
395
|
+
const prepared = operation === 'destroy' ? {} : this.controls(controls);
|
|
396
|
+
prepared.signal?.throwIfAborted();
|
|
397
|
+
assertPayload(input);
|
|
398
|
+
assertNoTransferAlias(input, options, prepared.inputOwnership);
|
|
399
|
+
const copiedOptions = clonePayload(options);
|
|
400
|
+
if (this.workerChannel) {
|
|
401
|
+
const progressId = this.nextProgressId++;
|
|
402
|
+
const request = {
|
|
403
|
+
input: clonePayload(input, prepared.inputOwnership),
|
|
404
|
+
options: copiedOptions,
|
|
405
|
+
outputOwnership: prepared.outputOwnership ?? 'transfer',
|
|
406
|
+
progressId
|
|
407
|
+
};
|
|
408
|
+
if (operation === 'stream-open') this.streamProgressId = progressId;
|
|
409
|
+
this.progressCallbacks.set(progressId, prepared.onProgress);
|
|
410
|
+
let callbackFailure: {reason: unknown} | undefined;
|
|
411
|
+
try {
|
|
412
|
+
const result = await this.workerChannel.channel.request(
|
|
413
|
+
operation,
|
|
414
|
+
request,
|
|
415
|
+
prepared.signal,
|
|
416
|
+
getTransferList(request)
|
|
417
|
+
);
|
|
418
|
+
callbackFailure =
|
|
419
|
+
this.callbackFailures.get(progressId) ??
|
|
420
|
+
(operation.startsWith('stream-') && this.streamProgressId !== undefined
|
|
421
|
+
? this.callbackFailures.get(this.streamProgressId)
|
|
422
|
+
: undefined);
|
|
423
|
+
if (callbackFailure) throw callbackFailure.reason;
|
|
424
|
+
return result;
|
|
425
|
+
} catch (reason) {
|
|
426
|
+
if (
|
|
427
|
+
operation === 'process' &&
|
|
428
|
+
!prepared.signal?.aborted &&
|
|
429
|
+
(reason instanceof TaskRequestError || callbackFailure)
|
|
430
|
+
)
|
|
431
|
+
throw reason;
|
|
432
|
+
this.invalid = true;
|
|
433
|
+
this.operationQueue.cancelPending(reason);
|
|
434
|
+
this.controller.abort(reason);
|
|
435
|
+
await this.workerChannel.destroy(reason);
|
|
436
|
+
throw reason;
|
|
437
|
+
} finally {
|
|
438
|
+
this.progressCallbacks.delete(progressId);
|
|
439
|
+
if (this.streamProgressId !== progressId) this.callbackFailures.delete(progressId);
|
|
440
|
+
}
|
|
441
|
+
}
|
|
442
|
+
if (this.pool) {
|
|
443
|
+
try {
|
|
444
|
+
return await processOnWorker(
|
|
445
|
+
this.descriptor!,
|
|
446
|
+
{operation, input: clonePayload(input, prepared.inputOwnership), options: copiedOptions},
|
|
447
|
+
this.workerOptions({...prepared, inputOwnership: 'transfer'})
|
|
448
|
+
);
|
|
449
|
+
} catch (error) {
|
|
450
|
+
// A transport error can indicate loss of pinned state. Conservatively
|
|
451
|
+
// invalidate rather than silently starting a new worker incarnation.
|
|
452
|
+
this.invalid = true;
|
|
453
|
+
await this.pool.destroy(error);
|
|
454
|
+
throw error;
|
|
455
|
+
}
|
|
456
|
+
}
|
|
457
|
+
if (operation === 'destroy') return this.runtime.destroy();
|
|
458
|
+
const copied = clonePayload(input, prepared.inputOwnership);
|
|
459
|
+
const context = this.runtimeContext(prepared);
|
|
460
|
+
if (operation === 'initialize') {
|
|
461
|
+
const result = await this.runtime.initialize(copied, context);
|
|
462
|
+
prepared.signal?.throwIfAborted();
|
|
463
|
+
return result;
|
|
464
|
+
}
|
|
465
|
+
const result = await this.runtime.process(copied, copiedOptions, context);
|
|
466
|
+
prepared.signal?.throwIfAborted();
|
|
467
|
+
return clonePayload(result, prepared.outputOwnership ?? 'transfer');
|
|
468
|
+
}
|
|
469
|
+
|
|
470
|
+
private runtimeContext(prepared: TaskRunControls) {
|
|
471
|
+
return {
|
|
472
|
+
...localContext(prepared),
|
|
473
|
+
requestHost: async (
|
|
474
|
+
operation: string,
|
|
475
|
+
payload: object,
|
|
476
|
+
controls: Pick<TaskRunControls, 'inputOwnership' | 'outputOwnership'> = {}
|
|
477
|
+
) => {
|
|
478
|
+
const signal = prepared.signal ?? this.controller.signal;
|
|
479
|
+
signal.throwIfAborted();
|
|
480
|
+
const handler = this.initializationControls.onRequest;
|
|
481
|
+
if (!handler) throw new Error('No host request handler configured');
|
|
482
|
+
const result = await handler(
|
|
483
|
+
operation,
|
|
484
|
+
clonePayload(payload, controls.inputOwnership),
|
|
485
|
+
signal
|
|
486
|
+
);
|
|
487
|
+
signal.throwIfAborted();
|
|
488
|
+
return structuredClone(result, {
|
|
489
|
+
transfer: controls.outputOwnership === 'transfer' ? getTransferList(result) : []
|
|
490
|
+
});
|
|
491
|
+
},
|
|
492
|
+
emitHost: (operation: string, payload: object) =>
|
|
493
|
+
this.initializationControls.onEvent?.(operation, structuredClone(payload))
|
|
494
|
+
};
|
|
495
|
+
}
|
|
496
|
+
|
|
497
|
+
private enqueue<T>(operation: () => Promise<T>): Promise<T> {
|
|
498
|
+
if (this.closed) return Promise.reject(new Error('Initialized task is closed'));
|
|
499
|
+
return this.operationQueue.run('exclusive', operation);
|
|
500
|
+
}
|
|
501
|
+
|
|
502
|
+
private serialStream<T>(
|
|
503
|
+
operation: (self: this) => AsyncIterable<T>,
|
|
504
|
+
signal?: AbortSignal
|
|
505
|
+
): AsyncIterableIterator<T> {
|
|
506
|
+
const waiting = new AbortController();
|
|
507
|
+
const queueSignal = AbortSignal.any(
|
|
508
|
+
[waiting.signal, this.controller.signal, signal].filter((value): value is AbortSignal =>
|
|
509
|
+
Boolean(value)
|
|
510
|
+
)
|
|
511
|
+
);
|
|
512
|
+
let started = false;
|
|
513
|
+
const iterator = this.acquireStream(operation, queueSignal, () => {
|
|
514
|
+
started = true;
|
|
515
|
+
});
|
|
516
|
+
const cancelWaiting = () => {
|
|
517
|
+
if (!started) waiting.abort(new Error('Stream returned before execution'));
|
|
518
|
+
};
|
|
519
|
+
return {
|
|
520
|
+
[Symbol.asyncIterator]() {
|
|
521
|
+
return this;
|
|
522
|
+
},
|
|
523
|
+
next: () => iterator.next(),
|
|
524
|
+
return: async () => {
|
|
525
|
+
cancelWaiting();
|
|
526
|
+
return iterator.return(undefined);
|
|
527
|
+
},
|
|
528
|
+
throw: async reason => {
|
|
529
|
+
cancelWaiting();
|
|
530
|
+
return iterator.throw(reason);
|
|
531
|
+
}
|
|
532
|
+
};
|
|
533
|
+
}
|
|
534
|
+
|
|
535
|
+
private async *acquireStream<T>(
|
|
536
|
+
operation: (self: this) => AsyncIterable<T>,
|
|
537
|
+
signal: AbortSignal,
|
|
538
|
+
onStart: () => void
|
|
539
|
+
): AsyncGenerator<T, void, unknown> {
|
|
540
|
+
if (this.closed) throw new Error('Initialized task is closed');
|
|
541
|
+
let acquire!: () => void;
|
|
542
|
+
const acquired = new Promise<void>(resolve => {
|
|
543
|
+
acquire = resolve;
|
|
544
|
+
});
|
|
545
|
+
let release!: () => void;
|
|
546
|
+
const held = new Promise<void>(resolve => {
|
|
547
|
+
release = resolve;
|
|
548
|
+
});
|
|
549
|
+
const lease = this.operationQueue.run(
|
|
550
|
+
'exclusive',
|
|
551
|
+
async () => {
|
|
552
|
+
acquire();
|
|
553
|
+
await held;
|
|
554
|
+
},
|
|
555
|
+
signal
|
|
556
|
+
);
|
|
557
|
+
await Promise.race([acquired, lease]);
|
|
558
|
+
if (signal.aborted) {
|
|
559
|
+
release();
|
|
560
|
+
throw signal.reason;
|
|
561
|
+
}
|
|
562
|
+
onStart();
|
|
563
|
+
const iterator = operation(this)[Symbol.asyncIterator]();
|
|
564
|
+
let stopping: Promise<void> | undefined;
|
|
565
|
+
const stop = () => {
|
|
566
|
+
stopping ??= (async () => {
|
|
567
|
+
try {
|
|
568
|
+
await iterator.return?.();
|
|
569
|
+
} finally {
|
|
570
|
+
this.streams.delete(stop);
|
|
571
|
+
release();
|
|
572
|
+
}
|
|
573
|
+
})();
|
|
574
|
+
return stopping;
|
|
575
|
+
};
|
|
576
|
+
this.streams.add(stop);
|
|
577
|
+
try {
|
|
578
|
+
while (true) {
|
|
579
|
+
this.controller.signal.throwIfAborted();
|
|
580
|
+
const next = await iterator.next();
|
|
581
|
+
if (next.done) return;
|
|
582
|
+
yield next.value;
|
|
583
|
+
}
|
|
584
|
+
} finally {
|
|
585
|
+
await stop();
|
|
586
|
+
}
|
|
587
|
+
}
|
|
588
|
+
}
|
|
589
|
+
|
|
590
|
+
/**
|
|
591
|
+
* Owns execution capacity and task lifetimes. No shared singleton or task registry.
|
|
592
|
+
* This experimental prototype deliberately exposes only implemented controls.
|
|
593
|
+
*/
|
|
594
|
+
export class TaskRunner {
|
|
595
|
+
private maxConcurrency: number;
|
|
596
|
+
private active = new Set<InitializedTask<any>>();
|
|
597
|
+
private count = 0;
|
|
598
|
+
private waiters: Array<{
|
|
599
|
+
resolve: () => void;
|
|
600
|
+
reject: (error: unknown) => void;
|
|
601
|
+
}> = [];
|
|
602
|
+
private closed = false;
|
|
603
|
+
private closing?: Promise<void>;
|
|
604
|
+
private initializing = new Set<Promise<unknown>>();
|
|
605
|
+
private iterations = new Set<AbortController>();
|
|
606
|
+
|
|
607
|
+
constructor(options: TaskRunnerOptions = {}) {
|
|
608
|
+
this.maxConcurrency = options.maxConcurrency ?? 1;
|
|
609
|
+
if (!Number.isSafeInteger(this.maxConcurrency) || this.maxConcurrency < 1)
|
|
610
|
+
throw new RangeError('maxConcurrency must be a positive safe integer');
|
|
611
|
+
}
|
|
612
|
+
|
|
613
|
+
/** Execute synchronous hooks immediately on the calling thread, without queueing. */
|
|
614
|
+
runTaskSync<D extends AnyTask>(
|
|
615
|
+
task: D & SynchronousTask<D>,
|
|
616
|
+
input: TaskInput<D>,
|
|
617
|
+
...args: RequestArgs<TaskSyncRunOptions<D>>
|
|
618
|
+
): TaskOutput<D> {
|
|
619
|
+
if (this.closed) throw new Error('Task runner is closed');
|
|
620
|
+
if (this.count >= this.maxConcurrency)
|
|
621
|
+
throw new Error('Task runner has no synchronous capacity');
|
|
622
|
+
this.count++;
|
|
623
|
+
try {
|
|
624
|
+
return runTaskSync(task, input, args[0]);
|
|
625
|
+
} finally {
|
|
626
|
+
const waiter = this.waiters.shift();
|
|
627
|
+
if (waiter) waiter.resolve();
|
|
628
|
+
else this.count--;
|
|
629
|
+
}
|
|
630
|
+
}
|
|
631
|
+
|
|
632
|
+
initializeTask<D extends AnyTask>(
|
|
633
|
+
task: D,
|
|
634
|
+
initialization: Initialization<D>,
|
|
635
|
+
controls: TaskInitializeControls = {}
|
|
636
|
+
): Promise<InitializedTask<D>> {
|
|
637
|
+
const pending = this.open(task, initialization, controls);
|
|
638
|
+
this.initializing.add(pending);
|
|
639
|
+
void pending.then(
|
|
640
|
+
() => this.initializing.delete(pending),
|
|
641
|
+
() => this.initializing.delete(pending)
|
|
642
|
+
);
|
|
643
|
+
return pending;
|
|
644
|
+
}
|
|
645
|
+
|
|
646
|
+
async runTask<D extends AnyTask>(
|
|
647
|
+
task: D,
|
|
648
|
+
input: TaskInput<D>,
|
|
649
|
+
...args: RequestArgs<TaskRunOptions<D>>
|
|
650
|
+
): Promise<TaskOutput<D>> {
|
|
651
|
+
const request = (args[0] as any) ?? {};
|
|
652
|
+
const handle = await this.initializeTask(task, request.initialization ?? {}, {
|
|
653
|
+
...request,
|
|
654
|
+
inputOwnership: request.initializationOwnership ?? 'copy'
|
|
655
|
+
});
|
|
656
|
+
return finish(handle, () => handle.runTask(input, request));
|
|
657
|
+
}
|
|
658
|
+
|
|
659
|
+
async *runTasks<D extends AnyTask>(
|
|
660
|
+
task: D,
|
|
661
|
+
inputs: Iterable<TaskInput<D>> | AsyncIterable<TaskInput<D>>,
|
|
662
|
+
...args: RequestArgs<TaskRunsOptions<D>>
|
|
663
|
+
): AsyncIterable<TaskOutput<D>> {
|
|
664
|
+
const request = (args[0] as any) ?? {};
|
|
665
|
+
if (this.closed) throw new Error('Task runner is closed');
|
|
666
|
+
if (request.initializationOwnership === 'transfer')
|
|
667
|
+
throw new TypeError('runTasks initialization is a reusable template; use copy or share');
|
|
668
|
+
const concurrency = request.concurrency ?? 1;
|
|
669
|
+
if (!Number.isSafeInteger(concurrency) || concurrency < 1 || concurrency > this.maxConcurrency)
|
|
670
|
+
throw new RangeError('concurrency must be between 1 and maxConcurrency');
|
|
671
|
+
const handles: InitializedTask<D>[] = [];
|
|
672
|
+
const busy = new Set<InitializedTask<D>>();
|
|
673
|
+
const pending: Array<
|
|
674
|
+
Promise<{
|
|
675
|
+
kind: 'result';
|
|
676
|
+
handle: InitializedTask<D>;
|
|
677
|
+
value?: TaskOutput<D>;
|
|
678
|
+
error?: unknown;
|
|
679
|
+
failed?: boolean;
|
|
680
|
+
}>
|
|
681
|
+
> = [];
|
|
682
|
+
const controller = new AbortController();
|
|
683
|
+
this.iterations.add(controller);
|
|
684
|
+
const signal = request.signal
|
|
685
|
+
? AbortSignal.any([request.signal, controller.signal])
|
|
686
|
+
: controller.signal;
|
|
687
|
+
const iterator = asAsync(inputs, signal)[Symbol.asyncIterator]();
|
|
688
|
+
let finished = false;
|
|
689
|
+
let reading: Promise<{kind: 'input'; next: IteratorResult<TaskInput<D>>}> | undefined;
|
|
690
|
+
try {
|
|
691
|
+
while (!finished || pending.length) {
|
|
692
|
+
signal.throwIfAborted();
|
|
693
|
+
if (!finished && !reading && pending.length < concurrency) {
|
|
694
|
+
reading = iterator.next().then(next => ({kind: 'input' as const, next}));
|
|
695
|
+
}
|
|
696
|
+
const event = await Promise.race([
|
|
697
|
+
...(pending.length ? [pending[0]!] : []),
|
|
698
|
+
...(reading ? [reading] : [])
|
|
699
|
+
]);
|
|
700
|
+
if (event.kind === 'result') {
|
|
701
|
+
pending.shift();
|
|
702
|
+
busy.delete(event.handle);
|
|
703
|
+
if (event.failed) throw event.error;
|
|
704
|
+
yield event.value!;
|
|
705
|
+
continue;
|
|
706
|
+
}
|
|
707
|
+
reading = undefined;
|
|
708
|
+
if (event.next.done) {
|
|
709
|
+
finished = true;
|
|
710
|
+
continue;
|
|
711
|
+
}
|
|
712
|
+
let handle = handles.find(candidate => !busy.has(candidate));
|
|
713
|
+
// Check capacity immediately before opening: open reserves it synchronously.
|
|
714
|
+
// Never wait for an extra slot while already holding one.
|
|
715
|
+
if (!handle && (handles.length === 0 || this.count < this.maxConcurrency)) {
|
|
716
|
+
handle = await this.initializeTask(
|
|
717
|
+
task,
|
|
718
|
+
clonePayload(request.initialization ?? {}, request.initializationOwnership),
|
|
719
|
+
{
|
|
720
|
+
...request,
|
|
721
|
+
signal,
|
|
722
|
+
inputOwnership: request.initializationOwnership ?? 'copy'
|
|
723
|
+
}
|
|
724
|
+
);
|
|
725
|
+
handles.push(handle);
|
|
726
|
+
}
|
|
727
|
+
if (!handle) {
|
|
728
|
+
const result = await pending.shift()!;
|
|
729
|
+
busy.delete(result.handle);
|
|
730
|
+
if (result.failed) throw result.error;
|
|
731
|
+
yield result.value!;
|
|
732
|
+
handle = result.handle;
|
|
733
|
+
}
|
|
734
|
+
busy.add(handle);
|
|
735
|
+
const current = handle;
|
|
736
|
+
pending.push(
|
|
737
|
+
handle.runTask(event.next.value, {...request, signal}).then(
|
|
738
|
+
value => ({kind: 'result' as const, handle: current, value}),
|
|
739
|
+
error => ({kind: 'result' as const, handle: current, failed: true, error})
|
|
740
|
+
)
|
|
741
|
+
);
|
|
742
|
+
}
|
|
743
|
+
} finally {
|
|
744
|
+
this.iterations.delete(controller);
|
|
745
|
+
controller.abort(new Error('Task iteration closed'));
|
|
746
|
+
try {
|
|
747
|
+
if (reading) await reading.catch(() => {});
|
|
748
|
+
if (!finished) await iterator.return?.();
|
|
749
|
+
} finally {
|
|
750
|
+
await Promise.all(pending);
|
|
751
|
+
await Promise.all(handles.map(handle => handle.close()));
|
|
752
|
+
}
|
|
753
|
+
}
|
|
754
|
+
}
|
|
755
|
+
|
|
756
|
+
async *runTaskInBatches<D extends AnyTask>(
|
|
757
|
+
task: D,
|
|
758
|
+
inputs: Iterable<TaskBatchInput<D>> | AsyncIterable<TaskBatchInput<D>>,
|
|
759
|
+
...args: RequestArgs<TaskBatchRunOptions<D>>
|
|
760
|
+
): AsyncIterable<TaskBatchOutput<D>> {
|
|
761
|
+
const request = (args[0] as any) ?? {};
|
|
762
|
+
const handle = await this.initializeTask(task, request.initialization ?? {}, {
|
|
763
|
+
...request,
|
|
764
|
+
inputOwnership: request.initializationOwnership ?? 'copy'
|
|
765
|
+
});
|
|
766
|
+
try {
|
|
767
|
+
yield* handle.runTaskInBatches(inputs, request);
|
|
768
|
+
} finally {
|
|
769
|
+
await handle.close();
|
|
770
|
+
}
|
|
771
|
+
}
|
|
772
|
+
|
|
773
|
+
/** Close owned handles and workers. Finish or return active iterators first. */
|
|
774
|
+
close(): Promise<void> {
|
|
775
|
+
if (!this.closing) {
|
|
776
|
+
this.closed = true;
|
|
777
|
+
for (const waiter of this.waiters.splice(0))
|
|
778
|
+
waiter.reject(new Error('Task runner is closed'));
|
|
779
|
+
this.closing = (async () => {
|
|
780
|
+
await Promise.allSettled(this.initializing);
|
|
781
|
+
const results = await Promise.allSettled([...this.active].map(handle => handle.close()));
|
|
782
|
+
const failure = results.find(result => result.status === 'rejected');
|
|
783
|
+
if (failure?.status === 'rejected') throw failure.reason;
|
|
784
|
+
})();
|
|
785
|
+
}
|
|
786
|
+
return this.closing;
|
|
787
|
+
}
|
|
788
|
+
|
|
789
|
+
async terminate(reason: unknown = new Error('Task runner terminated')): Promise<void> {
|
|
790
|
+
for (const controller of this.iterations) controller.abort(reason);
|
|
791
|
+
const closing = this.close();
|
|
792
|
+
await Promise.allSettled([...this.active].map(handle => handle.terminate(reason)));
|
|
793
|
+
await closing;
|
|
794
|
+
}
|
|
795
|
+
|
|
796
|
+
private async open<D extends AnyTask>(
|
|
797
|
+
task: D,
|
|
798
|
+
initialization: object,
|
|
799
|
+
controls: TaskInitializeControls
|
|
800
|
+
): Promise<InitializedTask<D>> {
|
|
801
|
+
if (this.closed) throw new Error('Task runner is closed');
|
|
802
|
+
controls.signal?.throwIfAborted();
|
|
803
|
+
if (this.count >= this.maxConcurrency) {
|
|
804
|
+
await new Promise<void>((resolve, reject) => {
|
|
805
|
+
const waiter = {
|
|
806
|
+
resolve: () => {
|
|
807
|
+
cleanup();
|
|
808
|
+
resolve();
|
|
809
|
+
},
|
|
810
|
+
reject: (error: unknown) => {
|
|
811
|
+
cleanup();
|
|
812
|
+
reject(error);
|
|
813
|
+
}
|
|
814
|
+
};
|
|
815
|
+
const abort = () => {
|
|
816
|
+
this.waiters = this.waiters.filter(item => item !== waiter);
|
|
817
|
+
waiter.reject(controls.signal?.reason);
|
|
818
|
+
};
|
|
819
|
+
const cleanup = () => controls.signal?.removeEventListener('abort', abort);
|
|
820
|
+
this.waiters.push(waiter);
|
|
821
|
+
controls.signal?.addEventListener('abort', abort, {once: true});
|
|
822
|
+
if (controls.signal?.aborted) abort();
|
|
823
|
+
});
|
|
824
|
+
} else this.count++;
|
|
825
|
+
let handle: InitializedTask<D> | undefined;
|
|
826
|
+
let released = false;
|
|
827
|
+
const release = () => {
|
|
828
|
+
if (released) return;
|
|
829
|
+
released = true;
|
|
830
|
+
if (handle) this.active.delete(handle);
|
|
831
|
+
const waiter = this.waiters.shift();
|
|
832
|
+
if (waiter) waiter.resolve();
|
|
833
|
+
else this.count--;
|
|
834
|
+
};
|
|
835
|
+
try {
|
|
836
|
+
if (this.closed) throw new Error('Task runner is closed');
|
|
837
|
+
handle = new InitializedTask(task, release, controls);
|
|
838
|
+
this.active.add(handle);
|
|
839
|
+
await handle.initialize(initialization, controls);
|
|
840
|
+
return handle;
|
|
841
|
+
} catch (error) {
|
|
842
|
+
release();
|
|
843
|
+
throw error;
|
|
844
|
+
}
|
|
845
|
+
}
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
async function finish<T>(handle: InitializedTask<any>, operation: () => Promise<T>): Promise<T> {
|
|
849
|
+
let result: T;
|
|
850
|
+
try {
|
|
851
|
+
result = await operation();
|
|
852
|
+
} catch (error) {
|
|
853
|
+
try {
|
|
854
|
+
await handle.close();
|
|
855
|
+
} catch (cleanup) {
|
|
856
|
+
throw new AggregateError([error, cleanup], 'Task processing and destruction failed');
|
|
857
|
+
}
|
|
858
|
+
throw error;
|
|
859
|
+
}
|
|
860
|
+
await handle.close();
|
|
861
|
+
return result;
|
|
862
|
+
}
|
|
863
|
+
|
|
864
|
+
async function* asAsync<T>(
|
|
865
|
+
inputs: Iterable<T> | AsyncIterable<T>,
|
|
866
|
+
signal?: AbortSignal
|
|
867
|
+
): AsyncIterable<T> {
|
|
868
|
+
const iterator =
|
|
869
|
+
Symbol.asyncIterator in inputs ? inputs[Symbol.asyncIterator]() : inputs[Symbol.iterator]();
|
|
870
|
+
let done = false;
|
|
871
|
+
let blocked = false;
|
|
872
|
+
try {
|
|
873
|
+
while (true) {
|
|
874
|
+
const next = await new Promise<IteratorResult<T>>((resolve, reject) => {
|
|
875
|
+
const cleanup = () => signal?.removeEventListener('abort', abort);
|
|
876
|
+
const abort = () => {
|
|
877
|
+
cleanup();
|
|
878
|
+
reject(signal?.reason);
|
|
879
|
+
};
|
|
880
|
+
signal?.addEventListener('abort', abort, {once: true});
|
|
881
|
+
if (signal?.aborted) {
|
|
882
|
+
abort();
|
|
883
|
+
return;
|
|
884
|
+
}
|
|
885
|
+
try {
|
|
886
|
+
blocked = true;
|
|
887
|
+
Promise.resolve(iterator.next()).then(
|
|
888
|
+
value => {
|
|
889
|
+
blocked = false;
|
|
890
|
+
cleanup();
|
|
891
|
+
resolve(value);
|
|
892
|
+
},
|
|
893
|
+
error => {
|
|
894
|
+
blocked = false;
|
|
895
|
+
cleanup();
|
|
896
|
+
reject(error);
|
|
897
|
+
}
|
|
898
|
+
);
|
|
899
|
+
} catch (error) {
|
|
900
|
+
blocked = false;
|
|
901
|
+
cleanup();
|
|
902
|
+
reject(error);
|
|
903
|
+
}
|
|
904
|
+
});
|
|
905
|
+
if (next.done) {
|
|
906
|
+
done = true;
|
|
907
|
+
return;
|
|
908
|
+
}
|
|
909
|
+
yield next.value;
|
|
910
|
+
}
|
|
911
|
+
} finally {
|
|
912
|
+
if (!done) {
|
|
913
|
+
if (blocked) {
|
|
914
|
+
try {
|
|
915
|
+
void Promise.resolve(iterator.return?.()).catch(() => {});
|
|
916
|
+
} catch {
|
|
917
|
+
/* A blocked producer cannot be forced to settle. */
|
|
918
|
+
}
|
|
919
|
+
} else {
|
|
920
|
+
await iterator.return?.();
|
|
921
|
+
}
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
}
|
|
925
|
+
|
|
926
|
+
function assertNoTransferAlias(input: unknown, options: unknown, ownership?: string): void {
|
|
927
|
+
if (ownership === 'transfer') {
|
|
928
|
+
const metadata = new Set(getTransferList(options));
|
|
929
|
+
if (getTransferList(input).some(buffer => metadata.has(buffer))) {
|
|
930
|
+
throw new Error('Transferred input aliases reusable options; use inputOwnership: copy');
|
|
931
|
+
}
|
|
932
|
+
}
|
|
933
|
+
}
|