@math.gl/tasks 0.0.0-stage → 5.0.0-beta.10

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