@h-ai/scheduler 1.0.0-beta.30 → 1.0.0-beta.31

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/README.md CHANGED
@@ -4,316 +4,27 @@
4
4
 
5
5
  [框架首页](../../README.md) · 相关模块:[@h-ai/core](../core/README.md) · [@h-ai/reldb](../reldb/README.md)
6
6
 
7
- 定时任务调度模块,支持统一任务模型、cron 调度、JS 函数字符串 / HTTP API 执行、任务持久化、执行日志查询,以及全局任务生命周期回调。
7
+ 用 `scheduler` 按 cron 表达式运行任务。任务可执行 JavaScript 处理函数或调用 HTTP 接口。模块把任务设置和执行日志写入数据库,也可在执行前后调用应用提供的函数。
8
8
 
9
9
  ## 快速开始
10
10
 
11
- ### 依赖
11
+ 使用 pnpm 安装:`pnpm add @h-ai/scheduler @h-ai/reldb`。
12
12
 
13
- - `@h-ai/reldb` — 必须先初始化共享数据库,保存任务、执行 journal 与自动续租;`enableDb` 只能为 true。
13
+ [跟着最小示例完成接入](../../docs/usage/function/scheduler.md#quick-start)。
14
14
 
15
- ```ts
16
- import { reldb } from '@h-ai/reldb'
17
- import { scheduler } from '@h-ai/scheduler'
15
+ ## 配置清单
18
16
 
19
- await reldb.init({ type: 'sqlite', database: './scheduler.db' })
17
+ 生成的项目在 `config/_scheduler.yml` 中设置任务检查间隔和执行租约时长。应用启动代码读取该文件,把配置对象传给 `scheduler.init(config)`。
20
18
 
21
- await scheduler.init({
22
- enableDb: true,
23
- maxLogs: 1000,
24
- retentionDays: 30,
25
- hooks: {
26
- onTaskStart(event) {
27
- void event
28
- },
29
- },
30
- })
19
+ 在[模块配置清单](../../docs/usage/configuration/scheduler.md)中查阅配置入口、默认值、取值限制和生效条件。
31
20
 
32
- await scheduler.register({
33
- id: 'health-check',
34
- name: '健康检查',
35
- description: '每 5 分钟执行一次系统健康检查',
36
- cron: '*/5 * * * *',
37
- params: { channel: 'ops' },
38
- handler: {
39
- kind: 'api',
40
- url: 'https://api.example.com/health',
41
- method: 'GET',
42
- timeout: 10000,
43
- },
44
- })
21
+ ## 功能说明
45
22
 
46
- await scheduler.register({
47
- id: 'cleanup',
48
- name: '清理过期数据',
49
- description: '每日凌晨执行过期数据清理',
50
- cron: '0 2 * * *',
51
- deleteAfterRun: true,
52
- params: { source: 'nightly' },
53
- handler: {
54
- kind: 'js',
55
- code: '(context) => ({ taskId: context.taskId, params: context.params })',
56
- },
57
- })
23
+ [查 API 清单](../../docs/usage/function/scheduler.md#api-reference),包含调用入口、输入、返回值和用法。
58
24
 
59
- scheduler.start()
25
+ ## 数据结构
60
26
 
61
- const manualResult = await scheduler.trigger('cleanup', { source: 'admin-console' })
62
- const logs = await scheduler.getLogs({
63
- triggerType: 'manual',
64
- triggerSource: 'admin-console',
65
- startedAfter: Date.now() - 24 * 60 * 60 * 1000,
66
- })
67
-
68
- scheduler.stop()
69
- await scheduler.close()
70
- ```
71
-
72
- ## 功能
73
-
74
- - 按 cron 定时执行,也可从业务代码手动触发。
75
- - 支持 HTTP、受信任的 JavaScript 和应用 Hook,提供重试与取消。
76
- - 共享数据库持久化任务、执行状态与可续期租约,支持未知结果隔离。
77
-
78
- ### 功能输入输出
79
-
80
- 以下片段依赖本节完整初始化流程。示例中的业务值由宿主校验和授权后传入;异步领域结果先判断 success,再读取 data。表中 void 表示操作已完成且没有返回数据,null 表示不存在;同步工厂/工具直接返回表中类型。
81
-
82
- #### scheduler
83
-
84
- 任务定义管理:完整任务、ID、ID+补丁或无参数刷新,分别返回 void HaiResult。tasks 是最近成功只读快照,不是权限或实时数据库依据。
85
-
86
- | 入口 | 输入参数 | 成功结果 | 调用示例 |
87
- | ------------------------ | --------------- | -------- | ---------------------------------------------------------------------------------------------- |
88
- | `scheduler.register` | task | `void` | `await scheduler.register({ id: 'daily', name: 'Daily', cron: '0 2 * * *', timezone: 'UTC' })` |
89
- | `scheduler.unregister` | taskId | `void` | `await scheduler.unregister('daily')` |
90
- | `scheduler.updateTask` | taskId, updates | `void` | `await scheduler.updateTask('daily', { enabled: false })` |
91
- | `scheduler.refreshTasks` | 无参数 | `void` | `await scheduler.refreshTasks()` |
92
-
93
- #### scheduler
94
-
95
- start/stop 无参数返回同步 HaiResult;trigger 输入任务 ID/参数返回一次执行日志;getLogs 输入过滤/分页返回日志页。stop 不代表在途副作用已撤销。
96
-
97
- | 入口 | 输入参数 | 成功结果 | 调用示例 |
98
- | ------------------- | --------------- | ----------------------------------- | ---------------------------------------------------- |
99
- | `scheduler.start` | 无参数 | `void` | `scheduler.start()` |
100
- | `scheduler.stop` | 无参数 | `void` | `scheduler.stop()` |
101
- | `scheduler.trigger` | taskId, options | `TaskExecutionLog` | `await scheduler.trigger('daily')` |
102
- | `scheduler.getLogs` | options | `PaginatedResult<TaskExecutionLog>` | `await scheduler.getLogs({ page: 1, pageSize: 20 })` |
103
-
104
- #### scheduler
105
-
106
- 接入业务执行/事件,输入回调集合或无参清除,返回同步 HaiResult。Hook 必须响应 signal 并保证外部效果幂等。
107
-
108
- | 入口 | 输入参数 | 成功结果 | 调用示例 |
109
- | ---------------------- | -------- | -------- | ------------------------------- |
110
- | `scheduler.setHooks` | hooks | `void` | `scheduler.setHooks(taskHooks)` |
111
- | `scheduler.clearHooks` | 无参数 | `void` | `scheduler.clearHooks()` |
112
-
113
- #### scheduler.execution
114
-
115
- 权威执行账本。get 输入 occurrenceId 返回项/null;两种 list 输入 limit/offset 返回数组;repairLog 输入 ID 幂等补日志;resolveUnknown 输入 ID、人工终态及 expectedUpdatedAt 条件释放槽位,返回 void。
116
-
117
- | 入口 | 输入参数 | 成功结果 | 调用示例 |
118
- | ------------------------------------- | ------------------------ | --------------------------------- | -------------------------------------------------------------------------------------------------- |
119
- | `scheduler.execution.get` | occurrenceId | `SchedulerExecutionEntry \| null` | `await scheduler.execution.get(occurrenceId)` |
120
- | `scheduler.execution.listUnknown` | options | `SchedulerExecutionEntry[]` | `await scheduler.execution.listUnknown({ limit: 20, offset: 0 })` |
121
- | `scheduler.execution.listLogFailures` | options | `SchedulerExecutionEntry[]` | `await scheduler.execution.listLogFailures({ limit: 20, offset: 0 })` |
122
- | `scheduler.execution.repairLog` | occurrenceId | `void` | `await scheduler.execution.repairLog(occurrenceId)` |
123
- | `scheduler.execution.resolveUnknown` | occurrenceId, resolution | `void` | `await scheduler.execution.resolveUnknown(occurrenceId, { status: 'success', expectedUpdatedAt })` |
124
-
125
- ### 统一任务模型
126
-
127
- ```ts
128
- interface TaskDefinition {
129
- id: string
130
- name: string
131
- description?: string
132
- cron: string
133
- timezone?: string // IANA 时区,例如 Asia/Shanghai;省略时为 UTC,不读取节点 TZ
134
- enabled?: boolean
135
- deleteAfterRun?: boolean
136
- idempotent?: boolean
137
- retry?: {
138
- maxAttempts: number
139
- backoffMs?: number[]
140
- }
141
- params?: Record<string, unknown>
142
- handler?: ApiTaskConfig | JsTaskConfig
143
- }
144
-
145
- interface ApiTaskConfig {
146
- kind: 'api'
147
- url: string
148
- method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
149
- headers?: Record<string, string>
150
- body?: unknown
151
- maxResponseBytes?: number
152
- timeout?: number
153
- }
154
-
155
- interface JsTaskConfig {
156
- kind: 'js'
157
- code: string // JS 函数字符串
158
- timeout?: number
159
- }
160
- ```
161
-
162
- 说明:
163
-
164
- - 所有任务都可持久化到数据库,包括 `kind: 'js'` 的任务
165
- - JS 任务会在运行时编译,并基于源码做缓存,避免每次触发都重新编译
166
- - `handler` 可为空;此时可通过全局 `hooks.onTaskExecute` 统一执行
167
-
168
- > ⚠️ **安全警示**:`kind: 'js'` 仅适用于受信任的服务端代码。当前实现基于 Node.js `vm` 做便捷执行,**不是安全沙箱**;禁止直接接收用户、租户或后台任意输入的 JS 字符串。可配置任务优先使用 `kind: 'api'` 或 `hooks.onTaskExecute`。
169
-
170
- ### 任务生命周期回调
171
-
172
- 初始化时传入或运行时通过 `setHooks()` 设置:
173
-
174
- ```ts
175
- await scheduler.init({
176
- enableDb: true,
177
- hooks: {
178
- onTaskStart(event) {
179
- void event
180
- },
181
- async onTaskExecute(event) {
182
- return { via: 'hook', source: event.context.trigger.source }
183
- },
184
- onTaskInterrupted(event) {
185
- void event
186
- },
187
- onTaskFinish(event) {
188
- void event
189
- },
190
- },
191
- })
192
- ```
193
-
194
- ### 执行日志
195
-
196
- 查询日志时可按触发来源过滤:
197
-
198
- ```ts
199
- const logs = await scheduler.getLogs({
200
- taskId: 'cleanup',
201
- triggerType: 'manual',
202
- triggerSource: 'admin-console',
203
- startedAfter: Date.now() - 24 * 60 * 60 * 1000,
204
- startedBefore: Date.now(),
205
- pagination: { page: 1, pageSize: 20 },
206
- })
207
- ```
208
-
209
- 执行日志支持自动清理策略(初始化时配置):
210
-
211
- - `maxLogs`:最多保留 N 条日志
212
- - `retentionDays`:最多保留最近 N 天日志
213
-
214
- ### API 概览
215
-
216
- - `init(config?)`
217
- - `register(task)`
218
- - `unregister(taskId)`
219
- - `updateTask(taskId, updates)`
220
- - `refreshTasks()`
221
- - `start()` / `stop()`
222
- - `trigger(taskId, { source?, idempotencyKey? })`
223
- - `getLogs(options?)`
224
- - `execution.listLogFailures(options?)` / `execution.repairLog(occurrenceId)`
225
- - `execution.get(occurrenceId)` / `execution.listUnknown(options?)` / `execution.resolveUnknown(occurrenceId, input)`
226
- - `setHooks(hooks)` / `clearHooks()`
227
- - `tasks` / `hooks` / `config` / `isInitialized` / `isRunning`
228
- - `close()`
229
-
230
- ### 运行行为与边界
231
-
232
- 所有节点必须先初始化同一共享 RelDB(跨主机生产使用 PostgreSQL/MySQL;SQLite 文件只适合可正确共享同一文件的本机进程)。数据库保存任务、执行 journal、全局任务占位和租约,`enableDb` 只能为 true;不再依赖缓存。`leaseMs` 默认 300000,范围 1000~86400000 毫秒,执行中自动续期。cron、手动和跨周期执行均争用同一任务槽,过期 owner 不能续活或提交。节点每个 `tickInterval` 刷新定义,`tasks` 只是最近成功快照;定义读取失败、删除、禁用、改期均中断旧尝试,已发生副作用不会回滚。
233
-
234
- `context.occurrenceId` 是持久发生标识;同一 cron 分钟跨节点一致,手动可传 1~128 字符 `idempotencyKey` 重用原记录,省略时每次独立。`executionToken` 每次领取变化,`sequence` / `attempt` 提供执行代信息。API 会覆盖 `Idempotency-Key`、`X-Scheduler-Sequence`、`X-Scheduler-Attempt`、`X-Scheduler-Task`(任务 ID 使用 percent-encoding)。Hook 及生命周期回调已领取时的 `event.context` 使用同一发生标识;观测回调若产生副作用也须去重。
235
-
236
- 使用 PostgreSQL 时,同一分钟重启或多个节点同时领取可能遇到已有执行记录或被占用的任务槽。调度器将这些冲突作为正常竞争处理。排查任务是否完成时,用 `scheduler.execution.get(occurrenceId)` 查看执行状态,并保留账本和唯一约束以防止重复执行。
237
-
238
- `idempotent` 默认为 false;只有接收端已将幂等账本和全部副作用原子持久提交,才声明 true。租约过期的已执行任务仅在 true 时以同 occurrenceId 接管;非幂等或耗尽本 occurrence 保存的 retry.maxAttempts(默认 1,范围 1–100,包含首次执行及恢复)时进入 `unknown` 并继续占住任务槽。租约无法强制撤销暂停进程已发出的外部操作,单有 HTTP 头不构成去重实现。重试同样受幂等声明约束。
239
-
240
- `scheduler.execution.get(occurrenceId)` 查询权威状态;`listUnknown({ limit, offset })` 分页获取未知结果,limit 为 1~100,offset 为 0~1000000。可信人工先核实外部效果、确认旧 runner 已终止,再按 `expectedUpdatedAt` CAS 调用 `resolveUnknown(id, { status: 'success' | 'discarded', expectedUpdatedAt })` 释放占位;不能直接把 unknown 重排。`log.occurrenceId` 可作查询回执;`getLogs` 仅为尝试观测日志,日志保留策略不删除 journal/幂等历史。
241
-
242
- 日志的 `id` 是每次尝试固定的 UUID,`persistence.status` 与业务 `status` 独立:`persisted` 表示日志及确认回执已持久化;`pending` 表示业务终态已提交但日志待补写;`unconfirmed` 表示没有已确认的业务终态,不能据此补写成功。只有 owner 与有效租约条件提交的终态会发布完整尝试列表,随后才投影日志;失租节点不能投影成功。日志失败不会把业务成功改成失败,也不会因此重跑业务。
243
-
244
- 补写会缩小 pending 列表;批量补写应反复读取 offset=0,避免一边补写一边增加 offset 跳过记录。
245
-
246
- 可信服务端用 `execution.listLogFailures({ limit, offset })` 监控 pending(范围与 listUnknown 相同),用 `execution.repairLog(occurrenceId)` 从共享 journal 幂等补写;可跨节点、重启及并发调用。写入已提交但回执丢失时通过固定主键和完整内容核对去重。补写返回 `LOG_PERSIST_FAILED`(032)时继续保留 pending,并输出安全告警;全部数据库不可用且终态未提交时仍按 unknown 核对外部效果,不能假定存在可恢复结果。补写与日志保留均不调用业务 Hook。保留策略失败仅告警,不撤销已保存日志。`onTaskFinish` 是本地业务完成通知,其 unconfirmed 状态不是持久化确认;以 trigger 返回值及 execution.get 的 logPersistence 为准。
247
-
248
- 领取前竞争/跳过的 interrupted 仅为观测日志,没有可补写的终态;其写入未确认时返回 unconfirmed。JSON 大载荷保存完整结果和全部重试记录,避免 MySQL 的 255 字符截断;执行账本保持独立。关闭会等待在途补写,先关闭 scheduler 再关闭数据库。
249
-
250
- ```ts
251
- const result = await scheduler.trigger('cleanup', { idempotencyKey: 'cleanup-2026-10-23' })
252
- if (!result.success)
253
- return result
254
- if (result.data.persistence.status === 'pending' && result.data.occurrenceId) {
255
- const repaired = await scheduler.execution.repairLog(result.data.occurrenceId)
256
- if (!repaired.success)
257
- return repaired
258
- }
259
- // 不用日志补写失败重新 trigger 业务;定期按页扫描 listLogFailures。
260
- ```
261
-
262
- `await scheduler.close()` 停止接收并取消 HTTP、JS Worker 与重试等待,再等待执行链退出后清理状态。重新初始化等待关闭完成。所有生命周期事件提供 `signal`;Hook 必须监听取消并停止自己的外部副作用(框架无法强制终止同一线程中的业务代码),不要在 Hook 中阻塞事件循环。取消后的旧执行不再重试、不自动删除任务,也不会调用新实例的 Hook。关闭期间保持数据库可用,待 scheduler 关闭后再关闭依赖。
263
-
264
- JS 字符串在每次调用的独立 Worker 中执行,`timeout` 默认 30000 毫秒(含启动)。到期后终止并等待线程退出,再记录失败或重试;同步死循环也不会阻塞主事件循环。上下文及返回值必须支持结构化克隆。Worker 中的 `vm` 仍不是安全沙箱,代码必须来自受信任的服务端来源。
265
-
266
- API 任务的 `timeout`(默认 30000 毫秒)覆盖请求和完整响应体读取。`ApiTaskConfig.maxResponseBytes` 指定响应体实际接收字节上限(正安全整数,默认 1048576 即 1 MiB);例如 `maxResponseBytes: 10 * 1024 * 1024` 允许最大 10 MiB,非法值在请求前失败;超时、超限或非成功 HTTP 状态在默认非幂等模式进入 unknown;仅声明幂等能力后才按有限重试策略处理。
267
-
268
- `init()` 必须完整加载全部任务才返回成功。配置中的空 ID、重复 ID(含与持久化任务重复)、无效 cron,以及数据库读取或持久化任务解析失败,均返回失败并清空初始化状态;修正配置或数据后重新初始化。不要同时在 `tasks` 中重复声明已有的数据库任务。
269
-
270
- 调度循环按分钟匹配 cron,并从同一分钟生成持久 occurrenceId;延迟 tick 仍检查当前分钟,运行中每分钟只检查一次。
271
-
272
- 共享租约的首次领取、开始、续租、完成、过期扫描和隔离,均在同一条数据库 SQL 内计算或核验存储端时间。PostgreSQL 使用 clock_timestamp、MySQL 使用 SYSDATE(3)、SQLite 使用存储端 now;先查时间再写入不能替代最终 deadline 条件。cron 也读取 DB 时间选定分钟 occurrence 并匹配表达式,省略 timezone 时固定 UTC;显式 IANA 时区仅改变 cron 的墙上时间解释,节点 TZ 不改变身份或匹配。节点 Date.now 仅用于耗时诊断,不授权 owner;两个节点相差数小时也不会提前接管或延长过期凭据。行锁等待结束后仍须通过期限条件,失租结果不能投影成功日志。数据库服务自身的时间须由运维保持可信;未知外部副作用仍须核对,不能自动重放。
273
-
274
- ### 可选集成
275
-
276
- 调度任务触发 Reach 通知时,调度锁或任务完成不等于外部消息只投递一次。按 [Reach 队列语义](../reach/README.md) 使用持久 queueId;HTTP 接收端须原子持久去重,SMTP/短信等在途未知结果须人工核对,不能由调度重试直接重发。
277
-
278
- ### 定义一致性与持久化准备
279
-
280
- 任务定义的刷新、注册、更新和删除在同一进程内按接收顺序协调,包含写操作所需的刷新与提交。合法并发注册不会仅因快照交错而失败;真实数据库故障仍返回失败。close 先停止入口和 runner,取消只读等待和尚未开始写入的操作,再等待已开始的持久写入;迟到快照不发布,避免关闭后旧操作重新填充任务表。执行回调不占用这条队列;跨节点仍依靠共享数据库、版本与租约,不把进程内协调当分布式锁。
281
-
282
- 先初始化 RelDB,再调用 `scheduler.init()` 创建和校验任务、执行及日志表。结构不符时返回初始化失败。执行账本与观测日志各有用途,应分别管理。
283
-
284
- ## 配置
285
-
286
- 生命周期:init 输入后端/业务配置,成功后才能使用;close 在释放借用依赖前等待完成。返回值以快速开始示例和公开签名为准。
287
-
288
- 配置由宿主加载和校验,再传入本模块;私密值放服务端私有环境,不传到浏览器。按实际使用场景逐项选择后端、容量、期限和日志策略,修改后重新初始化并核验成功结果。
289
-
290
- [逐项配置说明、适用场景和示例](../../docs/usage/configuration/operations.md).
291
-
292
- ## 错误处理
293
-
294
- 领域操作先判断 `result.success`,失败按本模块错误定义与安全提示处理,服务端保留错误码、关联编号和脱敏原因。同步工具、工厂、流迭代及生命周期按各自签名处理,不把 Promise 完成视为业务成功。具体失败与恢复边界见对应功能。
295
-
296
- 所有公共 API(除 `close()`)返回 `HaiResult<T>`。
297
-
298
- 常用错误码:
299
-
300
- | 错误码 | code | 说明 |
301
- | ----------------------------------------- | ------------------- | ---------------- |
302
- | `HaiSchedulerError.NOT_INITIALIZED` | `hai:scheduler:010` | 未初始化 |
303
- | `HaiSchedulerError.INIT_FAILED` | `hai:scheduler:011` | 初始化失败 |
304
- | `HaiSchedulerError.CONFIG_ERROR` | `hai:scheduler:012` | 配置错误 |
305
- | `HaiSchedulerError.TASK_NOT_FOUND` | `hai:scheduler:020` | 任务不存在 |
306
- | `HaiSchedulerError.TASK_ALREADY_EXISTS` | `hai:scheduler:021` | 任务已存在 |
307
- | `HaiSchedulerError.INVALID_CRON` | `hai:scheduler:022` | Cron 表达式无效 |
308
- | `HaiSchedulerError.EXECUTION_FAILED` | `hai:scheduler:023` | 执行失败 |
309
- | `HaiSchedulerError.JS_EXECUTION_FAILED` | `hai:scheduler:024` | JS 执行失败 |
310
- | `HaiSchedulerError.API_EXECUTION_FAILED` | `hai:scheduler:025` | API 执行失败 |
311
- | `HaiSchedulerError.DB_SAVE_FAILED` | `hai:scheduler:026` | DB 保存失败 |
312
- | `HaiSchedulerError.ALREADY_RUNNING` | `hai:scheduler:027` | 已在运行 |
313
- | `HaiSchedulerError.NOT_RUNNING` | `hai:scheduler:028` | 未在运行 |
314
- | `HaiSchedulerError.JS_COMPILE_FAILED` | `hai:scheduler:030` | JS 编译失败 |
315
- | `HaiSchedulerError.HOOK_EXECUTION_FAILED` | `hai:scheduler:031` | Hook 执行失败 |
316
- | `HaiSchedulerError.LOG_PERSIST_FAILED` | `hai:scheduler:032` | 日志持久化未确认 |
27
+ 查看[数据结构](../../docs/usage/data/scheduler.md),了解任务、执行日志、分布式租约和恢复状态。
317
28
 
318
29
  ## 开发测试
319
30
 
package/dist/index.js CHANGED
@@ -5,7 +5,6 @@ import { randomUUID, createHash } from 'crypto';
5
5
  import { isDeepStrictEqual } from 'util';
6
6
  import { Cron } from 'croner';
7
7
  import { Script } from 'vm';
8
- import { Worker } from 'worker_threads';
9
8
 
10
9
  // src/scheduler-config.ts
11
10
  var SchedulerConfigSchema = z.object({
@@ -1650,12 +1649,16 @@ function compileJsTaskHandler(config) {
1650
1649
  signal?.throwIfAborted();
1651
1650
  return await new Promise((resolve, reject) => {
1652
1651
  const timeout = config.timeout ?? 3e4;
1653
- const worker = new Worker(new URL("./scheduler-js-worker.js", import.meta.url), {
1654
- workerData: { code: config.code, context },
1655
- execArgv: []
1656
- });
1652
+ const worker = core.worker.start(
1653
+ new URL("./scheduler-js-worker.js", import.meta.url),
1654
+ {
1655
+ workerData: { code: config.code, context },
1656
+ execArgv: []
1657
+ }
1658
+ );
1657
1659
  let settled = false;
1658
1660
  let timer;
1661
+ let unsubscribe;
1659
1662
  const aborted = () => finish(new Error(schedulerM("scheduler_closing")));
1660
1663
  function finish(error, result) {
1661
1664
  if (settled)
@@ -1663,15 +1666,15 @@ function compileJsTaskHandler(config) {
1663
1666
  settled = true;
1664
1667
  clearTimeout(timer);
1665
1668
  signal?.removeEventListener("abort", aborted);
1669
+ unsubscribe?.();
1666
1670
  void worker.terminate().then(() => error ? reject(error) : resolve(result), reject);
1667
1671
  }
1668
1672
  timer = setTimeout(() => finish(new Error(schedulerM("scheduler_jsTimedOut", {
1669
1673
  params: { timeout }
1670
1674
  }))), timeout);
1671
1675
  signal?.addEventListener("abort", aborted, { once: true });
1672
- worker.once("error", (error) => finish(error instanceof Error ? error : new Error(String(error))));
1673
- worker.once("exit", (code) => finish(new Error(`JS worker exited before returning a result (${code})`)));
1674
- worker.once("message", (message) => {
1676
+ void worker.exited.then(({ code, error }) => finish(error ?? new Error(`JS worker exited before returning a result (${code})`)));
1677
+ unsubscribe = worker.onMessage((message) => {
1675
1678
  if (message.success)
1676
1679
  finish(void 0, message.data);
1677
1680
  else