@voltro/workflow 0.83.1 → 0.85.0
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/CHANGELOG.md +1191 -0
- package/THIRD-PARTY-NOTICES.md +1 -119
- package/dist/cluster-F_bhqVP7.js +679 -0
- package/dist/cluster.d.ts +304 -280
- package/dist/cluster.js +2 -2
- package/dist/clusterTestSuite.d.ts +11 -11
- package/dist/clusterTestSuite.js +256 -256
- package/dist/index.d.ts +443 -333
- package/dist/index.js +5 -5
- package/dist/journalEncryption-DTyhUzaS.js +154 -0
- package/dist/{primitives-Btjhjm8P.js → primitives-DX04WTWh.js} +223 -199
- package/dist/primitives.d.ts +56 -31
- package/dist/primitives.js +2 -2
- package/dist/{src-DP-lKqaG.js → src-C2NEyUM8.js} +1111 -1053
- package/dist/{clusterDiagnostics-CGUtnJkX.js → workflowReadSelections-CZAUjP7f.js} +58 -46
- package/package.json +6 -9
- package/dist/cluster--WvQZFwk.js +0 -637
- package/dist/journalEncryption--n5VDdYO.js +0 -148
|
@@ -1,14 +1,16 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
3
|
-
import { $ as
|
|
4
|
-
import { DurableClock as
|
|
5
|
-
import {
|
|
6
|
-
import {
|
|
7
|
-
import {
|
|
8
|
-
import {
|
|
9
|
-
import {
|
|
1
|
+
import { O as e, S as t, T as n, _ as r, a as i, b as a, g as o, h as s, i as c, l, n as u, u as d, v as f, x as p } from "./journalEncryption-DTyhUzaS.js";
|
|
2
|
+
import { E as m, F as h, L as g, M as _, N as v, P as ee, R as y, T as b, w as te } from "./primitives-DX04WTWh.js";
|
|
3
|
+
import { $ as ne, A as x, Bt as S, Ct as re, D as ie, Dt as C, E as ae, Et as w, F as T, Ft as E, G as oe, Gt as se, It as ce, Jt as D, L as O, Lt as le, M as ue, Mt as de, Nt as fe, O as pe, Ot as me, Pt as k, R as A, Rt as he, St as ge, T as _e, Tt as ve, U as ye, W as be, Wt as xe, X as Se, Y as Ce, Yt as we, _ as Te, at as j, b as Ee, bt as De, ct as Oe, et as M, ht as ke, j as Ae, jt as je, k as Me, kt as Ne, lt as Pe, mt as N, n as Fe, o as Ie, ot as Le, rt as Re, tt as ze, ut as Be, vt as Ve, w as He, x as Ue, xt as We, yt as Ge, z as Ke } from "./workflowReadSelections-CZAUjP7f.js";
|
|
4
|
+
import { DurableClock as qe, DurableDeferred as Je, Workflow as Ye, WorkflowEngine as Xe } from "effect/workflow";
|
|
5
|
+
import { RateLimiter as Ze } from "effect/persistence";
|
|
6
|
+
import { Cause as P, Context as Qe, Effect as F, Exit as $e, Fiber as I, Layer as et, Result as L, Schema as R } from "effect";
|
|
7
|
+
import { WorkflowQueuedCancellationResultSchema as tt, publishServerError as nt } from "@voltro/protocol";
|
|
8
|
+
import { and as z, boolean as rt, derivedRowId as it, eq as B, generateId as at, gt as V, gte as ot, id as H, inSet as st, integer as U, isNotNull as ct, isNull as W, json as G, lt, or as ut, queryFor as dt, real as ft, reference as pt, registerRetention as mt, retentionTtlMsFromEnv as ht, table as K, text as q, timestamp as J } from "@voltro/database";
|
|
9
|
+
import { createHash as gt, randomUUID as _t } from "node:crypto";
|
|
10
|
+
import { types as vt } from "node:util";
|
|
11
|
+
import { WorkflowInstance as Y } from "effect/workflow/WorkflowEngine";
|
|
10
12
|
//#region src/inMemoryLayer.ts
|
|
11
|
-
var
|
|
13
|
+
var yt = et.merge(Xe.layerMemory, Ze.layer.pipe(et.provide(Ze.layerStoreMemory))), bt = K("_voltro_workflow_runs", {
|
|
12
14
|
id: H({ prefix: "wfrun" }),
|
|
13
15
|
tag: q(),
|
|
14
16
|
executionId: q().unique(),
|
|
@@ -31,7 +33,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
31
33
|
source: q().nullable(),
|
|
32
34
|
errorTag: q().nullable(),
|
|
33
35
|
errorMessage: q().nullable(),
|
|
34
|
-
cancelled:
|
|
36
|
+
cancelled: rt().default(!1),
|
|
35
37
|
discardedAt: J().nullable(),
|
|
36
38
|
discardedBy: q().nullable(),
|
|
37
39
|
startedAt: J().default("now"),
|
|
@@ -45,9 +47,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
45
47
|
"terminate",
|
|
46
48
|
"abandon"
|
|
47
49
|
]).nullable()
|
|
48
|
-
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]),
|
|
50
|
+
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), xt = K("_voltro_workflow_run_steps", {
|
|
49
51
|
id: H({ prefix: "wfstep" }),
|
|
50
|
-
runId:
|
|
52
|
+
runId: pt(() => bt, {
|
|
51
53
|
index: !1,
|
|
52
54
|
onDelete: "cascade"
|
|
53
55
|
}),
|
|
@@ -67,9 +69,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
67
69
|
startedAt: J().default("now"),
|
|
68
70
|
completedAt: J().nullable(),
|
|
69
71
|
durationMs: U().nullable()
|
|
70
|
-
}).index(["runId", "stepName"]).index(["startedAt"]),
|
|
72
|
+
}).index(["runId", "stepName"]).index(["startedAt"]), St = K("_voltro_workflow_run_events", {
|
|
71
73
|
id: H({ prefix: "wfev" }),
|
|
72
|
-
runId:
|
|
74
|
+
runId: pt(() => bt, {
|
|
73
75
|
index: !1,
|
|
74
76
|
onDelete: "cascade"
|
|
75
77
|
}),
|
|
@@ -78,7 +80,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
78
80
|
occurredAt: J().default("now"),
|
|
79
81
|
stepName: q().nullable(),
|
|
80
82
|
attempt: U().nullable()
|
|
81
|
-
}).index(["runId", "occurredAt"]).index(["eventType"]),
|
|
83
|
+
}).index(["runId", "occurredAt"]).index(["eventType"]), Ct = K("_voltro_workflow_start_contexts", {
|
|
82
84
|
id: H({ prefix: "wfctx" }),
|
|
83
85
|
workflowName: q(),
|
|
84
86
|
executionId: q().unique(),
|
|
@@ -93,10 +95,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
93
95
|
"abandon"
|
|
94
96
|
]).nullable(),
|
|
95
97
|
createdAt: J().default("now")
|
|
96
|
-
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]),
|
|
98
|
+
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), wt = K("_voltro_workflow_admission_locks", {
|
|
97
99
|
id: H({ prefix: "wfalk" }),
|
|
98
100
|
nonce: q()
|
|
99
|
-
}).nonReactive(),
|
|
101
|
+
}).nonReactive(), Tt = K("_voltro_workflow_parent_closures", {
|
|
100
102
|
id: H({ prefix: "wfpc" }),
|
|
101
103
|
runId: q(),
|
|
102
104
|
workflowName: q(),
|
|
@@ -109,9 +111,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
109
111
|
]),
|
|
110
112
|
closedAt: J(),
|
|
111
113
|
afterChildId: q().nullable(),
|
|
112
|
-
scanHasOpenChildren:
|
|
114
|
+
scanHasOpenChildren: rt().default(!1),
|
|
113
115
|
completedAt: J().nullable()
|
|
114
|
-
}).index(["executionId"]).index(["completedAt", "id"]).nonReactive(),
|
|
116
|
+
}).index(["executionId"]).index(["completedAt", "id"]).nonReactive(), Et = K("_voltro_workflow_control_requests", {
|
|
115
117
|
id: H({ prefix: "wfctl" }),
|
|
116
118
|
runId: q(),
|
|
117
119
|
workflowName: q(),
|
|
@@ -129,7 +131,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
129
131
|
resumeJournal: G().nullable(),
|
|
130
132
|
dispatchAttempts: U().default(0),
|
|
131
133
|
result: G().nullable()
|
|
132
|
-
}).index(["runId"]).index(["parentClosureId", "id"]).nonReactive(),
|
|
134
|
+
}).index(["runId"]).index(["parentClosureId", "id"]).nonReactive(), Dt = K("_voltro_workflow_failure_reports", {
|
|
133
135
|
id: H({ prefix: "wffr" }),
|
|
134
136
|
workflowName: q(),
|
|
135
137
|
tenantId: q().nullable(),
|
|
@@ -145,14 +147,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
145
147
|
handoffReceiptId: q().nullable(),
|
|
146
148
|
handoffAttempt: U().default(0),
|
|
147
149
|
acceptedExecutionId: q().nullable()
|
|
148
|
-
}).index(["sourceKind", "sourceId"]).nonReactive(),
|
|
150
|
+
}).index(["sourceKind", "sourceId"]).nonReactive(), Ot = K("_voltro_workflow_submissions", {
|
|
149
151
|
id: H({ prefix: "wfsub" }),
|
|
150
152
|
workflowName: q(),
|
|
151
153
|
tenantId: q().nullable(),
|
|
152
154
|
ledgerId: q(),
|
|
153
155
|
executionId: q().nullable(),
|
|
154
156
|
runId: q().nullable(),
|
|
155
|
-
receiptsBound:
|
|
157
|
+
receiptsBound: rt().default(!1),
|
|
156
158
|
preparedExecutionId: q().nullable(),
|
|
157
159
|
dispatchAttempts: U().default(0),
|
|
158
160
|
failureId: q().nullable(),
|
|
@@ -161,7 +163,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
161
163
|
callerContext: G().nullable(),
|
|
162
164
|
intentIds: G(),
|
|
163
165
|
eviction: G().nullable()
|
|
164
|
-
}).nonReactive(),
|
|
166
|
+
}).nonReactive(), kt = K("_voltro_workflow_start_receipts", {
|
|
165
167
|
id: H({ prefix: "wfrc" }),
|
|
166
168
|
workflowName: q(),
|
|
167
169
|
tenantId: q().nullable(),
|
|
@@ -169,7 +171,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
169
171
|
submissionId: q().maxLength(64).nullable(),
|
|
170
172
|
terminal: G().nullable(),
|
|
171
173
|
requestFingerprint: q().maxLength(64).nullable()
|
|
172
|
-
}).index(["pendingId"]).nonReactive(),
|
|
174
|
+
}).index(["pendingId"]).nonReactive(), At = K("_voltro_workflow_pending", {
|
|
173
175
|
id: H({ prefix: "wfp" }),
|
|
174
176
|
tenantId: q().nullable(),
|
|
175
177
|
workflowName: q(),
|
|
@@ -195,7 +197,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
195
197
|
attempts: U().default(0),
|
|
196
198
|
lastError: q().nullable(),
|
|
197
199
|
deadLetteredAt: J().nullable()
|
|
198
|
-
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]),
|
|
200
|
+
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), jt = K("_voltro_workflow_admissions", {
|
|
199
201
|
id: H({ prefix: "wfadm" }),
|
|
200
202
|
tenantId: q().nullable(),
|
|
201
203
|
workflowName: q(),
|
|
@@ -210,7 +212,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
210
212
|
mode: q().nullable(),
|
|
211
213
|
reason: q().nullable(),
|
|
212
214
|
collapsed: U().default(1),
|
|
213
|
-
waitedMs:
|
|
215
|
+
waitedMs: ft().nullable().narrowedFrom("integer"),
|
|
214
216
|
executionId: q().nullable(),
|
|
215
217
|
runId: q().nullable(),
|
|
216
218
|
singletonKey: q().nullable(),
|
|
@@ -220,21 +222,21 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
220
222
|
admittedAt: J().default("now"),
|
|
221
223
|
expiresAt: J().nullable(),
|
|
222
224
|
releasedAt: J().nullable()
|
|
223
|
-
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]),
|
|
225
|
+
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), Mt = K("_voltro_workflow_pauses", {
|
|
224
226
|
id: H({ prefix: "wfpause" }),
|
|
225
227
|
pausedAt: J().default("now"),
|
|
226
228
|
pausedBy: q().nullable(),
|
|
227
229
|
reason: q().nullable()
|
|
228
|
-
}),
|
|
230
|
+
}), Nt = async (e, t) => {
|
|
229
231
|
if (!Number.isFinite(t.now) || !Number.isFinite(new Date(t.now).getTime())) throw Error("Queued cancellation requires a valid timestamp");
|
|
230
|
-
let n = await
|
|
232
|
+
let n = await Be(e, t.receiptId);
|
|
231
233
|
if (n === void 0 || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Queued cancellation receipt is missing or belongs to another workflow or tenant");
|
|
232
234
|
if (n.terminal !== null) return {
|
|
233
235
|
kind: "terminal",
|
|
234
236
|
outcome: n.terminal
|
|
235
237
|
};
|
|
236
238
|
if (n.submissionId !== null) {
|
|
237
|
-
let t = await
|
|
239
|
+
let t = await C(e, n.submissionId);
|
|
238
240
|
if (t === void 0 || !t.receiptsBound || t.workflowName !== n.workflowName || t.tenantId !== n.tenantId || !t.intentIds.includes(n.pendingId)) throw Error("Queued cancellation receipt has no matching submission");
|
|
239
241
|
return {
|
|
240
242
|
kind: "submitted",
|
|
@@ -242,7 +244,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
242
244
|
};
|
|
243
245
|
}
|
|
244
246
|
let [r] = await e.query({
|
|
245
|
-
table:
|
|
247
|
+
table: T,
|
|
246
248
|
predicate: B("id", n.pendingId),
|
|
247
249
|
lock: "update",
|
|
248
250
|
order: [],
|
|
@@ -251,7 +253,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
251
253
|
projection: void 0
|
|
252
254
|
});
|
|
253
255
|
if (r === void 0) throw Error("Queued cancellation has no pending input or submission");
|
|
254
|
-
let i =
|
|
256
|
+
let i = j(r);
|
|
255
257
|
if (i.workflowName !== n.workflowName || i.tenantId !== n.tenantId || i.deadLetteredAt !== void 0) throw Error("Queued cancellation input has contradictory ownership or is dead-lettered");
|
|
256
258
|
let a = {
|
|
257
259
|
kind: "cancelled",
|
|
@@ -267,30 +269,44 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
267
269
|
kind: "terminal",
|
|
268
270
|
outcome: a
|
|
269
271
|
};
|
|
270
|
-
},
|
|
272
|
+
}, Pt = "_voltro_workflow_parent_closures", X = R.NonEmptyString, Ft = R.Struct({
|
|
271
273
|
id: X,
|
|
272
274
|
runId: X,
|
|
273
275
|
workflowName: X,
|
|
274
276
|
executionId: X,
|
|
275
277
|
generation: X,
|
|
276
|
-
parentStatus: R.
|
|
277
|
-
|
|
278
|
+
parentStatus: R.Literals([
|
|
279
|
+
"succeeded",
|
|
280
|
+
"failed",
|
|
281
|
+
"cancelled"
|
|
282
|
+
]),
|
|
283
|
+
closedAt: R.Date,
|
|
278
284
|
afterChildId: R.NullOr(X),
|
|
279
285
|
scanHasOpenChildren: R.Boolean,
|
|
280
|
-
completedAt: R.NullOr(R.
|
|
281
|
-
}),
|
|
286
|
+
completedAt: R.NullOr(R.Date)
|
|
287
|
+
}), It = R.Struct({
|
|
282
288
|
id: X,
|
|
283
289
|
tag: X,
|
|
284
290
|
executionId: X,
|
|
285
|
-
status: R.
|
|
291
|
+
status: R.Literals([
|
|
292
|
+
"running",
|
|
293
|
+
"suspended",
|
|
294
|
+
"succeeded",
|
|
295
|
+
"failed",
|
|
296
|
+
"cancelled"
|
|
297
|
+
]),
|
|
286
298
|
runnerGeneration: R.optional(R.NullOr(X)),
|
|
287
299
|
parentGeneration: R.optional(R.NullOr(X)),
|
|
288
|
-
parentClosePolicy: R.NullOr(R.
|
|
289
|
-
|
|
300
|
+
parentClosePolicy: R.NullOr(R.Literals([
|
|
301
|
+
"cancel",
|
|
302
|
+
"terminate",
|
|
303
|
+
"abandon"
|
|
304
|
+
]))
|
|
305
|
+
}), Lt = async (e, t, n) => {
|
|
290
306
|
if (t.parentClosePolicy !== "cancel" && t.parentClosePolicy !== "terminate") return !1;
|
|
291
307
|
if (typeof t.parentExecutionId != "string" || t.parentExecutionId.length === 0 || typeof t.parentGeneration != "string" || t.parentGeneration.length === 0) throw Error("Child entry requires its original parent execution and generation");
|
|
292
308
|
let r = n ?? (await e.query({
|
|
293
|
-
table:
|
|
309
|
+
table: Pt,
|
|
294
310
|
predicate: z(B("executionId", t.parentExecutionId), B("generation", t.parentGeneration)),
|
|
295
311
|
lock: "update",
|
|
296
312
|
order: [],
|
|
@@ -299,19 +315,19 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
299
315
|
projection: void 0
|
|
300
316
|
}))[0];
|
|
301
317
|
if (r === void 0) return !1;
|
|
302
|
-
let i = R.decodeUnknownSync(
|
|
318
|
+
let i = R.decodeUnknownSync(Ft)(r);
|
|
303
319
|
if (i.executionId !== t.parentExecutionId || i.generation !== t.parentGeneration) return !1;
|
|
304
|
-
let a = R.decodeUnknownSync(
|
|
320
|
+
let a = R.decodeUnknownSync(It)(t), o = it("wfctl", JSON.stringify([
|
|
305
321
|
"parent-close",
|
|
306
322
|
i.id,
|
|
307
323
|
a.id
|
|
308
|
-
])), s = await
|
|
324
|
+
])), s = await Me(e, o);
|
|
309
325
|
if (s !== void 0) {
|
|
310
326
|
if (s.runId !== a.id || s.workflowName !== a.tag || s.executionId !== a.executionId || s.operation === "resume" || s.cause?.reason !== "parent-close" || s.cause.detail?.closureId !== i.id) throw Error("Parent closure receipt belongs to another child");
|
|
311
327
|
} else {
|
|
312
328
|
if (a.status !== "running" && a.status !== "suspended") return !1;
|
|
313
329
|
if (a.runnerGeneration === void 0 || a.runnerGeneration === null) throw Error("Child entry requires its own generation");
|
|
314
|
-
await
|
|
330
|
+
await Ue(e, {
|
|
315
331
|
id: o,
|
|
316
332
|
runId: a.id,
|
|
317
333
|
workflowName: a.tag,
|
|
@@ -333,9 +349,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
333
349
|
});
|
|
334
350
|
}
|
|
335
351
|
return !0;
|
|
336
|
-
},
|
|
352
|
+
}, Rt = async (e, t, n = Date.now()) => {
|
|
337
353
|
let [r] = await e.query({
|
|
338
|
-
table:
|
|
354
|
+
table: Pt,
|
|
339
355
|
predicate: B("id", t),
|
|
340
356
|
lock: "update",
|
|
341
357
|
order: [],
|
|
@@ -344,7 +360,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
344
360
|
projection: void 0
|
|
345
361
|
});
|
|
346
362
|
if (r === void 0) throw Error("Parent closure is missing");
|
|
347
|
-
let i = R.decodeUnknownSync(
|
|
363
|
+
let i = R.decodeUnknownSync(Ft)(r);
|
|
348
364
|
if (i.completedAt !== null) return {
|
|
349
365
|
scanned: 0,
|
|
350
366
|
controls: 0,
|
|
@@ -364,10 +380,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
364
380
|
projection: void 0
|
|
365
381
|
}), o = 0, s = i.scanHasOpenChildren, c = null;
|
|
366
382
|
for (let t of a) {
|
|
367
|
-
let r = R.decodeUnknownSync(
|
|
383
|
+
let r = R.decodeUnknownSync(It)(t);
|
|
368
384
|
if (c = r.id, r.parentClosePolicy !== null && r.parentClosePolicy !== "abandon") {
|
|
369
385
|
if (r.parentGeneration === void 0 || r.parentGeneration === null) throw Error("Parent closure cannot attribute a child without its parent generation");
|
|
370
|
-
r.parentGeneration === i.generation && ((r.status === "running" || r.status === "suspended") && (s = !0), await
|
|
386
|
+
r.parentGeneration === i.generation && ((r.status === "running" || r.status === "suspended") && (s = !0), await Lt(e, t, i) && (o++, r.status === "suspended" && typeof r.runnerGeneration == "string" && await Gt(e, {
|
|
371
387
|
runId: r.id,
|
|
372
388
|
workflowName: r.tag,
|
|
373
389
|
executionId: r.executionId,
|
|
@@ -375,8 +391,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
375
391
|
}, n)));
|
|
376
392
|
}
|
|
377
393
|
}
|
|
378
|
-
let l = a.length < 100, u = l && !s && !await
|
|
379
|
-
if (await e.update(
|
|
394
|
+
let l = a.length < 100, u = l && !s && !await ae(e, i.id);
|
|
395
|
+
if (await e.update(Pt, i.id, {
|
|
380
396
|
afterChildId: l ? null : c,
|
|
381
397
|
scanHasOpenChildren: !l && s,
|
|
382
398
|
completedAt: u ? new Date(n) : null
|
|
@@ -386,19 +402,19 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
386
402
|
controls: o,
|
|
387
403
|
wrapped: l
|
|
388
404
|
};
|
|
389
|
-
},
|
|
405
|
+
}, zt = "_voltro_workflow_runs", Bt = R.NullOr(R.Struct({
|
|
390
406
|
requestId: R.NonEmptyString,
|
|
391
407
|
restartToken: R.NullOr(R.NonEmptyString)
|
|
392
|
-
})),
|
|
408
|
+
})), Vt = async (e, t, n, r) => {
|
|
393
409
|
if (typeof t.id != "string") throw Error("Child entry has no allocated run identity");
|
|
394
410
|
let i = {
|
|
395
411
|
runId: t.id,
|
|
396
412
|
workflowName: n.workflowName,
|
|
397
413
|
executionId: n.executionId,
|
|
398
414
|
generation: n.generation
|
|
399
|
-
}, a = await
|
|
415
|
+
}, a = await sn(e, i), o = await Lt(e, t);
|
|
400
416
|
if (!a && !o) return;
|
|
401
|
-
let s = await
|
|
417
|
+
let s = await qt(e, {
|
|
402
418
|
owner: i,
|
|
403
419
|
now: n.now,
|
|
404
420
|
durationMs: 0,
|
|
@@ -411,31 +427,31 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
411
427
|
previous: r,
|
|
412
428
|
terminalEvent: s.terminalEvent
|
|
413
429
|
};
|
|
414
|
-
},
|
|
415
|
-
let n = await
|
|
430
|
+
}, Ht = async (e, t) => {
|
|
431
|
+
let n = await Ie(e, t);
|
|
416
432
|
return {
|
|
417
|
-
...await
|
|
433
|
+
...await Vt(e, n.row, t, n.previous) ?? {
|
|
418
434
|
kind: "entered",
|
|
419
435
|
row: n.row,
|
|
420
436
|
previous: n.previous
|
|
421
437
|
},
|
|
422
438
|
restartEvent: n.event
|
|
423
439
|
};
|
|
424
|
-
},
|
|
440
|
+
}, Ut = async (e, t) => {
|
|
425
441
|
if ([
|
|
426
442
|
t.workflowName,
|
|
427
443
|
t.executionId,
|
|
428
444
|
t.generation
|
|
429
445
|
].some((e) => e.length === 0) || typeof t.initialRow.id != "string" || t.initialRow.id.length === 0 || !Number.isFinite(t.now)) throw Error("Workflow entry requires allocated identities and a finite timestamp");
|
|
430
446
|
let n = (await e.query({
|
|
431
|
-
table:
|
|
447
|
+
table: zt,
|
|
432
448
|
predicate: B("executionId", t.executionId),
|
|
433
449
|
lock: "update",
|
|
434
450
|
order: [],
|
|
435
451
|
take: 1,
|
|
436
452
|
skip: void 0,
|
|
437
453
|
projection: void 0
|
|
438
|
-
}))[0], r = R.decodeUnknownSync(
|
|
454
|
+
}))[0], r = R.decodeUnknownSync(Bt)(t.delivery ?? null), i = (r) => Vt(e, r, t, n);
|
|
439
455
|
if (n === void 0) {
|
|
440
456
|
if (r !== null && r.restartToken !== null) throw Error("Workflow restart delivery has no resident authorization");
|
|
441
457
|
if ((await e.query({
|
|
@@ -447,7 +463,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
447
463
|
skip: void 0,
|
|
448
464
|
projection: ["id"]
|
|
449
465
|
})).length !== 0) throw Error("Workflow execution is already terminal; restore its engine journal instead of re-entering the body");
|
|
450
|
-
let n = await e.insert(
|
|
466
|
+
let n = await e.insert(zt, {
|
|
451
467
|
...t.initialRow,
|
|
452
468
|
tag: t.workflowName,
|
|
453
469
|
executionId: t.executionId,
|
|
@@ -464,9 +480,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
464
480
|
};
|
|
465
481
|
}
|
|
466
482
|
if (n.tag !== t.workflowName || typeof n.id != "string") throw Error("Workflow entry execution belongs to a different resident run");
|
|
467
|
-
let a = R.decodeUnknownSync(
|
|
483
|
+
let a = R.decodeUnknownSync(Bt)(n.engineDelivery ?? null);
|
|
468
484
|
if (a?.requestId !== r?.requestId || a?.restartToken !== r?.restartToken) {
|
|
469
|
-
if (n.status === "failed" && r !== null && r.restartToken !== null && a?.requestId === r.requestId) return
|
|
485
|
+
if (n.status === "failed" && r !== null && r.restartToken !== null && a?.requestId === r.requestId) return Ht(e, {
|
|
470
486
|
runId: n.id,
|
|
471
487
|
workflowName: t.workflowName,
|
|
472
488
|
executionId: t.executionId,
|
|
@@ -489,8 +505,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
489
505
|
executionId: t.executionId,
|
|
490
506
|
generation: n.runnerGeneration
|
|
491
507
|
};
|
|
492
|
-
if (await
|
|
493
|
-
let i = await
|
|
508
|
+
if (await _e(e, r)) {
|
|
509
|
+
let i = await qt(e, {
|
|
494
510
|
owner: r,
|
|
495
511
|
now: t.now,
|
|
496
512
|
durationMs: 0,
|
|
@@ -514,7 +530,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
514
530
|
if (typeof s != "number" || !Number.isSafeInteger(s) || s < 0) throw Error("Workflow entry has an invalid resident reclaim counter");
|
|
515
531
|
let c = o ? s + 1 : 0;
|
|
516
532
|
if (!Number.isSafeInteger(c)) throw Error("Workflow reclaim counter exhausted");
|
|
517
|
-
let l = await e.update(
|
|
533
|
+
let l = await e.update(zt, n.id, {
|
|
518
534
|
runnerGeneration: t.generation,
|
|
519
535
|
runnerEnteredAt: new Date(t.now),
|
|
520
536
|
reclaimCount: c,
|
|
@@ -526,7 +542,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
526
542
|
});
|
|
527
543
|
if (l === null) throw Error("Workflow run disappeared while entering its new generation");
|
|
528
544
|
let u = await i(l);
|
|
529
|
-
return u === void 0 ? (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string" && await
|
|
545
|
+
return u === void 0 ? (n.status === "suspended" && n.runnerEnteredAt === null && typeof n.runnerGeneration == "string" && await Ae(e, {
|
|
530
546
|
runId: n.id,
|
|
531
547
|
workflowName: t.workflowName,
|
|
532
548
|
executionId: t.executionId,
|
|
@@ -536,7 +552,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
536
552
|
row: l,
|
|
537
553
|
previous: n
|
|
538
554
|
}) : u;
|
|
539
|
-
},
|
|
555
|
+
}, Wt = async (e, t) => {
|
|
540
556
|
if ([
|
|
541
557
|
t.runId,
|
|
542
558
|
t.workflowName,
|
|
@@ -544,7 +560,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
544
560
|
t.generation
|
|
545
561
|
].some((e) => e.length === 0)) throw Error("Workflow runner ownership requires non-empty identities");
|
|
546
562
|
let n = (await e.query({
|
|
547
|
-
table:
|
|
563
|
+
table: zt,
|
|
548
564
|
predicate: B("id", t.runId),
|
|
549
565
|
lock: "update",
|
|
550
566
|
order: [],
|
|
@@ -554,21 +570,21 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
554
570
|
}))[0];
|
|
555
571
|
if (n === void 0 || n.tag !== t.workflowName || n.executionId !== t.executionId) throw Error("Workflow runner ownership does not match its resident run");
|
|
556
572
|
return n;
|
|
557
|
-
},
|
|
558
|
-
let r = await
|
|
559
|
-
if (r.runnerGeneration !== t.generation || r.status !== "suspended" || r.runnerEnteredAt !== null || !await
|
|
560
|
-
if ((await
|
|
573
|
+
}, Gt = async (e, t, n) => {
|
|
574
|
+
let r = await Wt(e, t);
|
|
575
|
+
if (r.runnerGeneration !== t.generation || r.status !== "suspended" || r.runnerEnteredAt !== null || !await _e(e, t)) return !1;
|
|
576
|
+
if ((await qt(e, {
|
|
561
577
|
owner: t,
|
|
562
578
|
now: n,
|
|
563
579
|
durationMs: 0,
|
|
564
580
|
outcome: { status: "cancelled" }
|
|
565
581
|
}, "suspended")).kind !== "committed") throw Error("Suspended cancellation lost its resident owner");
|
|
566
582
|
return !0;
|
|
567
|
-
},
|
|
568
|
-
let r = await
|
|
583
|
+
}, Kt = async (e, t, n) => {
|
|
584
|
+
let r = await Wt(e, t);
|
|
569
585
|
if (r.runnerGeneration !== t.generation) return { kind: "superseded" };
|
|
570
586
|
if (r.status !== "running") return { kind: "not-running" };
|
|
571
|
-
let i = await e.update(
|
|
587
|
+
let i = await e.update(zt, t.runId, {
|
|
572
588
|
status: "suspended",
|
|
573
589
|
runnerEnteredAt: null,
|
|
574
590
|
errorTag: n.errorTag,
|
|
@@ -579,143 +595,143 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
579
595
|
kind: "committed",
|
|
580
596
|
row: i
|
|
581
597
|
};
|
|
582
|
-
},
|
|
583
|
-
let
|
|
584
|
-
if (
|
|
585
|
-
if (
|
|
586
|
-
if (!Number.isFinite(
|
|
587
|
-
let
|
|
588
|
-
if (
|
|
598
|
+
}, qt = async (e, n, r) => {
|
|
599
|
+
let i = await Wt(e, n.owner);
|
|
600
|
+
if (i.runnerGeneration !== n.owner.generation) return { kind: "superseded" };
|
|
601
|
+
if (i.status !== r) return { kind: "not-running" };
|
|
602
|
+
if (!Number.isFinite(n.now) || !Number.isFinite(n.durationMs) || n.durationMs < 0) throw Error("Workflow completion requires finite time and non-negative duration");
|
|
603
|
+
let o = n.outcome, s = null;
|
|
604
|
+
if (o.status === "failed" && (s = `wffr_${gt("sha256").update(JSON.stringify([
|
|
589
605
|
"run",
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
])).digest("hex").slice(0, 40)}`, await
|
|
594
|
-
id:
|
|
606
|
+
n.owner.workflowName,
|
|
607
|
+
n.owner.runId,
|
|
608
|
+
n.owner.generation
|
|
609
|
+
])).digest("hex").slice(0, 40)}`, await S(e, {
|
|
610
|
+
id: s,
|
|
595
611
|
sourceKind: "run",
|
|
596
|
-
sourceId:
|
|
597
|
-
workflowName:
|
|
598
|
-
tenantId:
|
|
599
|
-
handler: await
|
|
600
|
-
callerContext:
|
|
612
|
+
sourceId: n.owner.runId,
|
|
613
|
+
workflowName: n.owner.workflowName,
|
|
614
|
+
tenantId: o.tenantId,
|
|
615
|
+
handler: await E(e, n.owner.executionId, n.owner.workflowName, o.tenantId) ? null : o.handler,
|
|
616
|
+
callerContext: o.callerContext,
|
|
601
617
|
report: {
|
|
602
|
-
workflow:
|
|
603
|
-
payload:
|
|
604
|
-
errorTag:
|
|
605
|
-
errorMessage:
|
|
606
|
-
runId:
|
|
607
|
-
executionId:
|
|
618
|
+
workflow: n.owner.workflowName,
|
|
619
|
+
payload: i.payload,
|
|
620
|
+
errorTag: o.errorTag,
|
|
621
|
+
errorMessage: o.errorMessage,
|
|
622
|
+
runId: n.owner.runId,
|
|
623
|
+
executionId: n.owner.executionId,
|
|
608
624
|
reason: "the run failed",
|
|
609
|
-
failedAt:
|
|
625
|
+
failedAt: n.now
|
|
610
626
|
}
|
|
611
|
-
}), await
|
|
612
|
-
let
|
|
627
|
+
}), await k(e, s, n.now)), o.status === "cancelled") {
|
|
628
|
+
let t = (await pe((t) => e.query({
|
|
613
629
|
...t,
|
|
614
630
|
lock: "update"
|
|
615
|
-
}),
|
|
631
|
+
}), n.owner)).map((e) => ({
|
|
616
632
|
request: e,
|
|
617
|
-
cause:
|
|
633
|
+
cause: He(e)
|
|
618
634
|
})).find((e) => e.cause !== void 0);
|
|
619
|
-
if (
|
|
620
|
-
let
|
|
621
|
-
|
|
635
|
+
if (t !== void 0 && t.cause !== void 0) {
|
|
636
|
+
let r = R.decodeUnknownOption(R.Struct({ tenantId: R.NullOr(R.String) }))(i.subject), a = t.request.owner?.tenantId ?? (r._tag === "Some" ? r.value.tenantId : null);
|
|
637
|
+
s = `wffr_${gt("sha256").update(JSON.stringify([
|
|
622
638
|
"finish-timeout",
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
])).digest("hex").slice(0, 40)}`, await
|
|
627
|
-
id:
|
|
639
|
+
n.owner.workflowName,
|
|
640
|
+
n.owner.runId,
|
|
641
|
+
n.owner.generation
|
|
642
|
+
])).digest("hex").slice(0, 40)}`, await S(e, {
|
|
643
|
+
id: s,
|
|
628
644
|
sourceKind: "run",
|
|
629
|
-
sourceId:
|
|
630
|
-
workflowName:
|
|
631
|
-
tenantId:
|
|
632
|
-
handler: await
|
|
645
|
+
sourceId: n.owner.runId,
|
|
646
|
+
workflowName: n.owner.workflowName,
|
|
647
|
+
tenantId: a,
|
|
648
|
+
handler: await E(e, n.owner.executionId, n.owner.workflowName, a) ? null : t.cause.detail.onFailure,
|
|
633
649
|
callerContext: {
|
|
634
|
-
subject:
|
|
635
|
-
traceId:
|
|
636
|
-
source:
|
|
637
|
-
parentExecutionId:
|
|
638
|
-
parentGeneration:
|
|
639
|
-
parentClosePolicy:
|
|
650
|
+
subject: i.subject ?? null,
|
|
651
|
+
traceId: i.traceId ?? null,
|
|
652
|
+
source: i.source ?? null,
|
|
653
|
+
parentExecutionId: i.parentExecutionId ?? null,
|
|
654
|
+
parentGeneration: i.parentGeneration ?? null,
|
|
655
|
+
parentClosePolicy: i.parentClosePolicy ?? null
|
|
640
656
|
},
|
|
641
657
|
report: {
|
|
642
|
-
workflow:
|
|
643
|
-
payload:
|
|
658
|
+
workflow: n.owner.workflowName,
|
|
659
|
+
payload: i.payload,
|
|
644
660
|
errorTag: null,
|
|
645
661
|
errorMessage: null,
|
|
646
|
-
runId:
|
|
647
|
-
executionId:
|
|
648
|
-
reason:
|
|
649
|
-
failedAt:
|
|
662
|
+
runId: n.owner.runId,
|
|
663
|
+
executionId: n.owner.executionId,
|
|
664
|
+
reason: t.cause.reason,
|
|
665
|
+
failedAt: n.now
|
|
650
666
|
}
|
|
651
|
-
}), await
|
|
667
|
+
}), await k(e, s, n.now);
|
|
652
668
|
}
|
|
653
669
|
}
|
|
654
|
-
let
|
|
655
|
-
status:
|
|
656
|
-
completedAt: new Date(
|
|
657
|
-
durationMs:
|
|
658
|
-
cancelled:
|
|
670
|
+
let c = await e.update(zt, n.owner.runId, {
|
|
671
|
+
status: o.status,
|
|
672
|
+
completedAt: new Date(n.now),
|
|
673
|
+
durationMs: n.durationMs,
|
|
674
|
+
cancelled: o.status === "cancelled",
|
|
659
675
|
runnerEnteredAt: null,
|
|
660
|
-
output:
|
|
661
|
-
errorTag:
|
|
662
|
-
errorMessage:
|
|
676
|
+
output: o.status === "succeeded" ? l(n.owner.workflowName) ? t(o.output, `workflow '${n.owner.workflowName}' result`) : o.output : null,
|
|
677
|
+
errorTag: o.status === "failed" ? o.errorTag : null,
|
|
678
|
+
errorMessage: o.status === "failed" ? a(n.owner.workflowName, o.errorMessage) : null
|
|
663
679
|
});
|
|
664
|
-
if (
|
|
680
|
+
if (c === null) throw Error("Workflow run disappeared during terminal recording");
|
|
665
681
|
await e.insert("_voltro_workflow_parent_closures", {
|
|
666
|
-
id:
|
|
667
|
-
runId:
|
|
668
|
-
workflowName:
|
|
669
|
-
executionId:
|
|
670
|
-
generation:
|
|
671
|
-
parentStatus:
|
|
672
|
-
closedAt: new Date(
|
|
682
|
+
id: it("wfpc", JSON.stringify([n.owner.runId, n.owner.generation])),
|
|
683
|
+
runId: n.owner.runId,
|
|
684
|
+
workflowName: n.owner.workflowName,
|
|
685
|
+
executionId: n.owner.executionId,
|
|
686
|
+
generation: n.owner.generation,
|
|
687
|
+
parentStatus: o.status,
|
|
688
|
+
closedAt: new Date(n.now),
|
|
673
689
|
afterChildId: null,
|
|
674
690
|
scanHasOpenChildren: !1,
|
|
675
691
|
completedAt: null
|
|
676
692
|
});
|
|
677
|
-
let
|
|
678
|
-
id:
|
|
693
|
+
let u = await e.insert("_voltro_workflow_run_events", {
|
|
694
|
+
id: it("wfev", JSON.stringify([
|
|
679
695
|
"terminal",
|
|
680
|
-
|
|
681
|
-
|
|
696
|
+
n.owner.runId,
|
|
697
|
+
n.owner.generation
|
|
682
698
|
])),
|
|
683
|
-
runId:
|
|
684
|
-
eventType: `run-${
|
|
685
|
-
occurredAt: new Date(
|
|
699
|
+
runId: n.owner.runId,
|
|
700
|
+
eventType: `run-${o.status}`,
|
|
701
|
+
occurredAt: new Date(n.now),
|
|
686
702
|
stepName: null,
|
|
687
703
|
attempt: null,
|
|
688
704
|
payload: {
|
|
689
|
-
executionId:
|
|
690
|
-
generation:
|
|
691
|
-
durationMs:
|
|
692
|
-
...
|
|
693
|
-
errorTag:
|
|
694
|
-
errorMessage:
|
|
705
|
+
executionId: n.owner.executionId,
|
|
706
|
+
generation: n.owner.generation,
|
|
707
|
+
durationMs: n.durationMs,
|
|
708
|
+
...o.status === "failed" ? {
|
|
709
|
+
errorTag: o.errorTag,
|
|
710
|
+
errorMessage: a(n.owner.workflowName, o.errorMessage)
|
|
695
711
|
} : {}
|
|
696
712
|
}
|
|
697
713
|
});
|
|
698
|
-
await
|
|
699
|
-
for await (let
|
|
714
|
+
await x(e, n), await ze(e, n.owner.executionId, n.now);
|
|
715
|
+
for await (let t of We(e, n.owner.executionId, n.owner.workflowName)) {
|
|
700
716
|
let [r] = await e.query({
|
|
701
|
-
table:
|
|
702
|
-
predicate: B("id",
|
|
717
|
+
table: ue,
|
|
718
|
+
predicate: B("id", t.ledgerId),
|
|
703
719
|
lock: "update",
|
|
704
720
|
order: [],
|
|
705
721
|
take: 1,
|
|
706
722
|
skip: void 0,
|
|
707
723
|
projection: void 0
|
|
708
724
|
});
|
|
709
|
-
if (r === void 0 || r.workflowName !==
|
|
710
|
-
if (r.releasedAt === null && await e.update("_voltro_workflow_admissions",
|
|
725
|
+
if (r === void 0 || r.workflowName !== t.workflowName || r.tenantId !== t.tenantId || r.outcome !== "admitted" || r.executionId !== null && r.executionId !== n.owner.executionId) throw Error("Workflow terminal reservation does not match its resident submission");
|
|
726
|
+
if (r.releasedAt === null && await e.update("_voltro_workflow_admissions", t.ledgerId, { releasedAt: new Date(n.now) }) === null) throw Error("Workflow terminal reservation disappeared during release");
|
|
711
727
|
}
|
|
712
728
|
return {
|
|
713
729
|
kind: "committed",
|
|
714
|
-
row:
|
|
715
|
-
failureId:
|
|
716
|
-
terminalEvent:
|
|
730
|
+
row: c,
|
|
731
|
+
failureId: s,
|
|
732
|
+
terminalEvent: u
|
|
717
733
|
};
|
|
718
|
-
},
|
|
734
|
+
}, Jt = (e, t) => qt(e, t, "running"), Yt = K("_voltro_workflow_queued_cancellations", {
|
|
719
735
|
id: H({ prefix: "wfqc" }),
|
|
720
736
|
receiptId: q(),
|
|
721
737
|
workflowName: q(),
|
|
@@ -724,40 +740,37 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
724
740
|
cause: G().nullable(),
|
|
725
741
|
target: G(),
|
|
726
742
|
controlBinding: G().nullable()
|
|
727
|
-
}).index(["receiptId"]).index(["workflowName", "id"]).nonReactive(),
|
|
743
|
+
}).index(["receiptId"]).index(["workflowName", "id"]).nonReactive(), Xt = R.NullOr(R.Struct({
|
|
728
744
|
reason: R.NonEmptyString,
|
|
729
|
-
detail: R.optional(R.Record(
|
|
730
|
-
|
|
731
|
-
value: R.Unknown
|
|
732
|
-
}))
|
|
733
|
-
})), Jt = R.Struct({
|
|
745
|
+
detail: R.optional(R.Record(R.String, R.Unknown))
|
|
746
|
+
})), Zt = R.Struct({
|
|
734
747
|
id: R.NonEmptyString,
|
|
735
748
|
receiptId: R.NonEmptyString,
|
|
736
749
|
workflowName: R.NonEmptyString,
|
|
737
750
|
tenantId: R.NullOr(R.String),
|
|
738
|
-
requestedAt: R.
|
|
739
|
-
cause:
|
|
751
|
+
requestedAt: R.Date,
|
|
752
|
+
cause: Xt,
|
|
740
753
|
controlBinding: R.NullOr(R.Struct({
|
|
741
754
|
controlId: R.NonEmptyString,
|
|
742
755
|
runId: R.NonEmptyString,
|
|
743
756
|
executionId: R.NonEmptyString,
|
|
744
757
|
generation: R.NonEmptyString
|
|
745
758
|
})),
|
|
746
|
-
target: R.Union(R.Struct({
|
|
759
|
+
target: R.Union([R.Struct({
|
|
747
760
|
kind: R.Literal("submission"),
|
|
748
761
|
submissionId: R.NonEmptyString
|
|
749
762
|
}), R.Struct({
|
|
750
763
|
kind: R.Literal("terminal"),
|
|
751
764
|
receipt: R.Unknown
|
|
752
|
-
}))
|
|
753
|
-
}),
|
|
754
|
-
let t = R.decodeUnknownSync(
|
|
765
|
+
})])
|
|
766
|
+
}), Qt = (e) => {
|
|
767
|
+
let t = R.decodeUnknownSync(Zt)(e);
|
|
755
768
|
if (!Number.isFinite(t.requestedAt.getTime())) throw Error("Queued cancellation request has an invalid timestamp");
|
|
756
769
|
if (t.target.kind === "submission") return {
|
|
757
770
|
...t,
|
|
758
771
|
target: t.target
|
|
759
772
|
};
|
|
760
|
-
let n =
|
|
773
|
+
let n = Pe(t.target.receipt);
|
|
761
774
|
if (t.controlBinding !== null) throw Error("A non-executed start cannot have a run control binding");
|
|
762
775
|
if (n.id !== t.receiptId || n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.terminal === null) throw Error("Queued cancellation terminal evidence belongs to another start or is not terminal");
|
|
763
776
|
return {
|
|
@@ -767,9 +780,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
767
780
|
receipt: n
|
|
768
781
|
}
|
|
769
782
|
};
|
|
770
|
-
},
|
|
783
|
+
}, $t = async (e, t) => {
|
|
771
784
|
let [n] = await e.query({
|
|
772
|
-
table:
|
|
785
|
+
table: Yt.tableName,
|
|
773
786
|
predicate: B("id", t),
|
|
774
787
|
lock: "update",
|
|
775
788
|
order: [],
|
|
@@ -777,16 +790,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
777
790
|
skip: void 0,
|
|
778
791
|
projection: void 0
|
|
779
792
|
});
|
|
780
|
-
return n === void 0 ? void 0 :
|
|
781
|
-
},
|
|
793
|
+
return n === void 0 ? void 0 : Qt(n);
|
|
794
|
+
}, en = async (e, t) => {
|
|
782
795
|
let n = t.controlBinding;
|
|
783
796
|
if (n === null) throw Error("Queued cancellation has no control binding");
|
|
784
|
-
let r = await
|
|
797
|
+
let r = await Me(e, n.controlId);
|
|
785
798
|
if (r === void 0 || r.operation !== "cancel" || r.workflowName !== t.workflowName || r.runId !== n.runId || r.executionId !== n.executionId || r.generation !== n.generation || r.owner?.tenantId !== t.tenantId || r.result?.status === "running") throw Error("Queued cancellation lost its original resident control owner");
|
|
786
799
|
return r;
|
|
787
|
-
},
|
|
800
|
+
}, tn = async (e, t, n) => {
|
|
788
801
|
if (t.controlBinding === null) return;
|
|
789
|
-
let r = await
|
|
802
|
+
let r = await en(e, t);
|
|
790
803
|
if (r.result !== null) return;
|
|
791
804
|
let [i] = await e.query({
|
|
792
805
|
table: "_voltro_workflow_runs",
|
|
@@ -797,14 +810,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
797
810
|
skip: void 0,
|
|
798
811
|
projection: void 0
|
|
799
812
|
});
|
|
800
|
-
i !== void 0 && await
|
|
813
|
+
i !== void 0 && await Gt(e, {
|
|
801
814
|
runId: r.runId,
|
|
802
815
|
workflowName: r.workflowName,
|
|
803
816
|
executionId: r.executionId,
|
|
804
817
|
generation: r.generation
|
|
805
818
|
}, n);
|
|
806
|
-
},
|
|
807
|
-
let n = await
|
|
819
|
+
}, nn = async (e, t) => {
|
|
820
|
+
let n = await $t(e, t.requestId);
|
|
808
821
|
if (n === void 0) return {
|
|
809
822
|
kind: "unknown",
|
|
810
823
|
reason: "missing-request"
|
|
@@ -820,7 +833,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
820
833
|
};
|
|
821
834
|
}
|
|
822
835
|
if (n.controlBinding !== null) {
|
|
823
|
-
let t = await
|
|
836
|
+
let t = await en(e, n);
|
|
824
837
|
if (t.result !== null) return {
|
|
825
838
|
kind: t.result.kind,
|
|
826
839
|
request: n,
|
|
@@ -854,7 +867,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
854
867
|
run: r
|
|
855
868
|
};
|
|
856
869
|
}
|
|
857
|
-
let r = await
|
|
870
|
+
let r = await C(e, n.target.submissionId);
|
|
858
871
|
if (r === void 0 || !r.receiptsBound || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId) throw Error("Queued cancellation has no matching submission evidence");
|
|
859
872
|
return r.failureId === null ? r.retry.stoppedAt !== null || r.runId !== null ? {
|
|
860
873
|
kind: "unknown",
|
|
@@ -868,10 +881,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
868
881
|
request: n,
|
|
869
882
|
outcome: {
|
|
870
883
|
kind: "rejected",
|
|
871
|
-
failureId: await
|
|
884
|
+
failureId: await ke(e, r)
|
|
872
885
|
}
|
|
873
886
|
};
|
|
874
|
-
},
|
|
887
|
+
}, rn = (e, t) => {
|
|
875
888
|
let n = "request" in t ? t.request : void 0;
|
|
876
889
|
if (n !== void 0 && (n.id !== e.requestId || n.receiptId !== e.receiptId || n.workflowName !== e.workflowName)) throw Error("Queued control result belongs to another request or receipt");
|
|
877
890
|
let r = {
|
|
@@ -880,7 +893,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
880
893
|
receiptId: e.receiptId,
|
|
881
894
|
requestId: n?.id ?? null,
|
|
882
895
|
kind: t.kind
|
|
883
|
-
}, i = R.decodeUnknownSync(
|
|
896
|
+
}, i = R.decodeUnknownSync(tt);
|
|
884
897
|
if (t.kind === "unknown") return i({
|
|
885
898
|
...r,
|
|
886
899
|
observation: {
|
|
@@ -919,14 +932,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
919
932
|
...r,
|
|
920
933
|
observation: { kind: "pending" }
|
|
921
934
|
});
|
|
922
|
-
},
|
|
935
|
+
}, an = async (e, t) => {
|
|
923
936
|
let n = R.decodeUnknownSync(R.Struct({
|
|
924
937
|
id: R.NonEmptyString,
|
|
925
938
|
receiptId: R.NonEmptyString,
|
|
926
939
|
workflowName: R.NonEmptyString,
|
|
927
940
|
tenantId: R.NullOr(R.String),
|
|
928
|
-
requestedAt: R.
|
|
929
|
-
cause:
|
|
941
|
+
requestedAt: R.Date,
|
|
942
|
+
cause: Xt
|
|
930
943
|
}))({
|
|
931
944
|
id: t.requestId,
|
|
932
945
|
receiptId: t.receiptId,
|
|
@@ -936,31 +949,31 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
936
949
|
cause: t.cause ?? null
|
|
937
950
|
});
|
|
938
951
|
if (!Number.isFinite(n.requestedAt.getTime())) throw Error("Queued cancellation request requires a valid timestamp");
|
|
939
|
-
let r = await
|
|
952
|
+
let r = await $t(e, n.id);
|
|
940
953
|
if (r !== void 0) {
|
|
941
954
|
if (r.receiptId !== n.receiptId || r.workflowName !== n.workflowName || r.tenantId !== n.tenantId) throw Error("Queued cancellation identity belongs to a different start or owner");
|
|
942
|
-
return await
|
|
955
|
+
return await tn(e, r, t.now), r;
|
|
943
956
|
}
|
|
944
|
-
let i = await
|
|
957
|
+
let i = await Nt(e, t), a;
|
|
945
958
|
if (i.kind === "submitted") a = {
|
|
946
959
|
kind: "submission",
|
|
947
960
|
submissionId: i.submissionId
|
|
948
961
|
};
|
|
949
962
|
else {
|
|
950
|
-
let n = await
|
|
963
|
+
let n = await Be(e, t.receiptId);
|
|
951
964
|
if (n === void 0) throw Error("Cancelled start receipt disappeared during request acceptance");
|
|
952
965
|
a = {
|
|
953
966
|
kind: "terminal",
|
|
954
967
|
receipt: n
|
|
955
968
|
};
|
|
956
969
|
}
|
|
957
|
-
let o =
|
|
970
|
+
let o = Qt({
|
|
958
971
|
...n,
|
|
959
972
|
target: a,
|
|
960
973
|
controlBinding: null
|
|
961
974
|
});
|
|
962
|
-
if (await e.insert(
|
|
963
|
-
let n = await
|
|
975
|
+
if (await e.insert(Yt.tableName, o), a.kind === "submission") {
|
|
976
|
+
let n = await C(e, a.submissionId);
|
|
964
977
|
if (n === void 0) throw Error("Queued cancellation submission disappeared during acceptance");
|
|
965
978
|
if (n.preparedExecutionId !== null && n.dispatchAttempts > 0) {
|
|
966
979
|
let [r] = await e.query({
|
|
@@ -983,14 +996,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
983
996
|
workflowName: n.tag,
|
|
984
997
|
executionId: n.executionId,
|
|
985
998
|
generation: n.runnerGeneration
|
|
986
|
-
}, a = await
|
|
987
|
-
return await
|
|
999
|
+
}, a = await on(e, o.id, i);
|
|
1000
|
+
return await tn(e, a.request, t.now), a.request;
|
|
988
1001
|
}
|
|
989
1002
|
}
|
|
990
1003
|
}
|
|
991
1004
|
return o;
|
|
992
|
-
},
|
|
993
|
-
let r = await
|
|
1005
|
+
}, on = async (e, t, n) => {
|
|
1006
|
+
let r = await $t(e, t);
|
|
994
1007
|
if (r === void 0) throw Error("Queued cancellation request is missing");
|
|
995
1008
|
if (r.target.kind === "terminal") return {
|
|
996
1009
|
kind: "terminal",
|
|
@@ -999,9 +1012,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
999
1012
|
if (r.controlBinding !== null) return {
|
|
1000
1013
|
kind: "bound",
|
|
1001
1014
|
request: r,
|
|
1002
|
-
control: await
|
|
1015
|
+
control: await en(e, r)
|
|
1003
1016
|
};
|
|
1004
|
-
let i = await
|
|
1017
|
+
let i = await C(e, r.target.submissionId);
|
|
1005
1018
|
if (i === void 0 || i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || !i.receiptsBound || i.failureId !== null || i.dispatchAttempts === 0 || i.preparedExecutionId !== n.executionId || i.executionId !== null && i.executionId !== n.executionId || i.runId !== null && i.runId !== n.runId || n.workflowName !== r.workflowName) throw Error("Queued cancellation has no dispatched submission for this resident execution");
|
|
1006
1019
|
let [a] = await e.query({
|
|
1007
1020
|
table: "_voltro_workflow_runs",
|
|
@@ -1020,18 +1033,18 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1020
1033
|
"cancelled"
|
|
1021
1034
|
].includes(String(a.status))) throw Error("Queued cancellation generation or tenant does not match the resident run");
|
|
1022
1035
|
let s = {
|
|
1023
|
-
controlId:
|
|
1036
|
+
controlId: it("wfctl", JSON.stringify(["queued-cancel", r.id])),
|
|
1024
1037
|
runId: n.runId,
|
|
1025
1038
|
executionId: n.executionId,
|
|
1026
1039
|
generation: n.generation
|
|
1027
|
-
}, c = await
|
|
1040
|
+
}, c = await Ue(e, {
|
|
1028
1041
|
id: s.controlId,
|
|
1029
1042
|
...n,
|
|
1030
1043
|
operation: "cancel",
|
|
1031
1044
|
requestedAt: r.requestedAt.getTime(),
|
|
1032
1045
|
cause: r.cause
|
|
1033
1046
|
});
|
|
1034
|
-
if (await e.update(
|
|
1047
|
+
if (await e.update(Yt.tableName, r.id, { controlBinding: s }) === null) throw Error("Queued cancellation request disappeared during run binding");
|
|
1035
1048
|
return {
|
|
1036
1049
|
kind: "bound",
|
|
1037
1050
|
request: {
|
|
@@ -1040,14 +1053,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1040
1053
|
},
|
|
1041
1054
|
control: c
|
|
1042
1055
|
};
|
|
1043
|
-
},
|
|
1056
|
+
}, sn = async (e, t) => {
|
|
1044
1057
|
let n = /* @__PURE__ */ new Set();
|
|
1045
|
-
for await (let r of
|
|
1058
|
+
for await (let r of We(e, t.executionId, t.workflowName)) n.add(r.id);
|
|
1046
1059
|
if (n.size === 0) return !1;
|
|
1047
1060
|
let r, i = !1;
|
|
1048
1061
|
for (;;) {
|
|
1049
1062
|
let a = await e.query({
|
|
1050
|
-
table:
|
|
1063
|
+
table: Yt.tableName,
|
|
1051
1064
|
predicate: z(B("workflowName", t.workflowName), ...r === void 0 ? [] : [V("id", r)]),
|
|
1052
1065
|
lock: "update",
|
|
1053
1066
|
order: [{
|
|
@@ -1059,9 +1072,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1059
1072
|
projection: void 0
|
|
1060
1073
|
});
|
|
1061
1074
|
for (let o of a) {
|
|
1062
|
-
let a =
|
|
1075
|
+
let a = Qt(o);
|
|
1063
1076
|
if (r = a.id, a.target.kind !== "submission" || !n.has(a.target.submissionId)) continue;
|
|
1064
|
-
let s = await
|
|
1077
|
+
let s = await on(e, a.id, t);
|
|
1065
1078
|
if (s.kind === "bound") {
|
|
1066
1079
|
if (s.control.runId !== t.runId || s.control.executionId !== t.executionId || s.control.workflowName !== t.workflowName) throw Error("Queued cancellation entry does not match its original resident execution");
|
|
1067
1080
|
s.control.result === null && (i = !0);
|
|
@@ -1069,31 +1082,31 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1069
1082
|
}
|
|
1070
1083
|
if (a.length < 100) return i;
|
|
1071
1084
|
}
|
|
1072
|
-
},
|
|
1085
|
+
}, cn = R.Struct({
|
|
1073
1086
|
requestId: R.NonEmptyString,
|
|
1074
1087
|
receiptId: R.NonEmptyString,
|
|
1075
1088
|
workflowName: R.NonEmptyString,
|
|
1076
1089
|
tenantId: R.NullOr(R.String)
|
|
1077
|
-
}),
|
|
1078
|
-
let n = R.decodeUnknownSync(
|
|
1079
|
-
return await
|
|
1090
|
+
}), ln = async (e, t) => {
|
|
1091
|
+
let n = R.decodeUnknownSync(cn)(t);
|
|
1092
|
+
return await an(e, {
|
|
1080
1093
|
...n,
|
|
1081
1094
|
now: t.now,
|
|
1082
1095
|
...t.cause === void 0 ? {} : { cause: t.cause }
|
|
1083
|
-
}),
|
|
1084
|
-
},
|
|
1085
|
-
let n = R.decodeUnknownSync(
|
|
1086
|
-
return
|
|
1087
|
-
},
|
|
1096
|
+
}), un(e, n);
|
|
1097
|
+
}, un = async (e, t) => {
|
|
1098
|
+
let n = R.decodeUnknownSync(cn)(t);
|
|
1099
|
+
return rn(n, await nn(e, n));
|
|
1100
|
+
}, dn = async (e, t) => {
|
|
1088
1101
|
if (new Set(t.intentIds).size !== t.intentIds.length) throw Error("Admitted transfer requires distinct pending identities");
|
|
1089
|
-
let n = await
|
|
1102
|
+
let n = await C(e, t.id);
|
|
1090
1103
|
if (n !== void 0) {
|
|
1091
1104
|
if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId || n.ledgerId !== t.ledgerId || !n.receiptsBound) throw Error("Admitted transfer contradicts its existing submission");
|
|
1092
1105
|
return n;
|
|
1093
1106
|
}
|
|
1094
1107
|
for (let n of t.intentIds) {
|
|
1095
1108
|
let r = await e.query({
|
|
1096
|
-
table:
|
|
1109
|
+
table: T,
|
|
1097
1110
|
predicate: B("id", n),
|
|
1098
1111
|
order: [],
|
|
1099
1112
|
take: 1,
|
|
@@ -1102,19 +1115,19 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1102
1115
|
lock: "update"
|
|
1103
1116
|
});
|
|
1104
1117
|
if (r[0] === void 0) throw Error("Admitted transfer lost a selected input");
|
|
1105
|
-
let i =
|
|
1118
|
+
let i = j(r[0]);
|
|
1106
1119
|
if (i.workflowName !== t.workflowName || i.tenantId !== t.tenantId || i.deadLetteredAt !== void 0) throw Error("Admitted transfer selected a foreign or dead-lettered input");
|
|
1107
1120
|
}
|
|
1108
|
-
let r = await
|
|
1109
|
-
await
|
|
1121
|
+
let r = await ve(e, t);
|
|
1122
|
+
await Oe(e, r.id);
|
|
1110
1123
|
for (let t of r.intentIds) if (!await e.delete("_voltro_workflow_pending", t)) throw Error("Admitted input disappeared during submission transfer");
|
|
1111
1124
|
return {
|
|
1112
1125
|
...r,
|
|
1113
1126
|
receiptsBound: !0
|
|
1114
1127
|
};
|
|
1115
|
-
},
|
|
1128
|
+
}, fn = async (e, t) => we(e, (e) => pn(e, t)), pn = async (e, t) => {
|
|
1116
1129
|
if (t.id.length === 0 || t.intentIds.length === 0 || new Set(t.intentIds).size !== t.intentIds.length) throw Error("Queue transfer requires a submission identity and distinct pending identities");
|
|
1117
|
-
let n = await
|
|
1130
|
+
let n = await C(e, t.id);
|
|
1118
1131
|
if (n !== void 0) {
|
|
1119
1132
|
if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Admission submission identity belongs to a different workflow or tenant");
|
|
1120
1133
|
if (!n.receiptsBound) throw Error("Submission exists without completed queue transfer");
|
|
@@ -1127,7 +1140,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1127
1140
|
let r = [];
|
|
1128
1141
|
for (let n of t.intentIds) {
|
|
1129
1142
|
let i = await e.query({
|
|
1130
|
-
table:
|
|
1143
|
+
table: T,
|
|
1131
1144
|
predicate: B("id", n),
|
|
1132
1145
|
order: [],
|
|
1133
1146
|
take: 1,
|
|
@@ -1136,14 +1149,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1136
1149
|
lock: "update"
|
|
1137
1150
|
});
|
|
1138
1151
|
if (i[0] === void 0) return { kind: "selection-unavailable" };
|
|
1139
|
-
let a =
|
|
1152
|
+
let a = j(i[0]);
|
|
1140
1153
|
if (a.workflowName !== t.workflowName || a.tenantId !== t.tenantId) throw Error("Selected pending start belongs to a different workflow or tenant");
|
|
1141
1154
|
if (a.deadLetteredAt !== void 0 || a.dueAt > t.now) return { kind: "selection-unavailable" };
|
|
1142
1155
|
r.push(a);
|
|
1143
1156
|
}
|
|
1144
1157
|
let i = t.prepare(r);
|
|
1145
1158
|
if (i.control.workflowName !== t.workflowName) throw Error("Prepared submission belongs to a different workflow");
|
|
1146
|
-
let a = await
|
|
1159
|
+
let a = await je(e, {
|
|
1147
1160
|
...i,
|
|
1148
1161
|
id: t.id,
|
|
1149
1162
|
tenantId: t.tenantId,
|
|
@@ -1151,7 +1164,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1151
1164
|
now: t.now
|
|
1152
1165
|
});
|
|
1153
1166
|
if (a.kind !== "reserved") return a;
|
|
1154
|
-
await
|
|
1167
|
+
await Oe(e, t.id);
|
|
1155
1168
|
for (let t of r) if (!await e.delete("_voltro_workflow_pending", t.id)) throw Error("Pending start disappeared during queue transfer");
|
|
1156
1169
|
return {
|
|
1157
1170
|
...a,
|
|
@@ -1160,8 +1173,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1160
1173
|
receiptsBound: !0
|
|
1161
1174
|
}
|
|
1162
1175
|
};
|
|
1163
|
-
},
|
|
1164
|
-
let { store: t, control: n, now: r } = e, i = D(n, e.payload), a = await
|
|
1176
|
+
}, mn = async (e) => {
|
|
1177
|
+
let { store: t, control: n, now: r } = e, i = D(n, e.payload), a = await be({
|
|
1165
1178
|
store: t,
|
|
1166
1179
|
control: n,
|
|
1167
1180
|
keys: i,
|
|
@@ -1169,7 +1182,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1169
1182
|
now: r,
|
|
1170
1183
|
reconsidering: !1
|
|
1171
1184
|
});
|
|
1172
|
-
if (a.kind === "drop") return await
|
|
1185
|
+
if (a.kind === "drop") return await M({
|
|
1173
1186
|
store: t,
|
|
1174
1187
|
control: n,
|
|
1175
1188
|
keys: i,
|
|
@@ -1186,7 +1199,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1186
1199
|
kind: "dropped",
|
|
1187
1200
|
retryAfterMs: a.retryAfterMs
|
|
1188
1201
|
};
|
|
1189
|
-
if (a.kind === "skip") return await
|
|
1202
|
+
if (a.kind === "skip") return await M({
|
|
1190
1203
|
store: t,
|
|
1191
1204
|
control: n,
|
|
1192
1205
|
keys: i,
|
|
@@ -1206,7 +1219,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1206
1219
|
};
|
|
1207
1220
|
if (a.kind === "defer") return {
|
|
1208
1221
|
kind: "queued",
|
|
1209
|
-
intentId: await
|
|
1222
|
+
intentId: await Se({
|
|
1210
1223
|
store: t,
|
|
1211
1224
|
control: n,
|
|
1212
1225
|
decision: a,
|
|
@@ -1222,12 +1235,12 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1222
1235
|
};
|
|
1223
1236
|
let o = e.payload, s = [], c = 1;
|
|
1224
1237
|
if (n.batch !== void 0 && i.batchKey !== void 0) {
|
|
1225
|
-
let r = await
|
|
1238
|
+
let r = await hn(t, n.workflowName, i.batchKey, n.batch.maxSize);
|
|
1226
1239
|
o = { items: [...r.map((e) => e.payload), e.payload] }, s = r.map((e) => e.id), c = r.length + 1;
|
|
1227
1240
|
}
|
|
1228
1241
|
return {
|
|
1229
1242
|
kind: "start",
|
|
1230
|
-
ledgerId: await
|
|
1243
|
+
ledgerId: await M({
|
|
1231
1244
|
store: t,
|
|
1232
1245
|
control: n,
|
|
1233
1246
|
keys: i,
|
|
@@ -1250,7 +1263,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1250
1263
|
runId: a.evict.runId
|
|
1251
1264
|
} }
|
|
1252
1265
|
};
|
|
1253
|
-
},
|
|
1266
|
+
}, hn = async (e, t, n, r) => (await e.query({
|
|
1254
1267
|
table: "_voltro_workflow_pending",
|
|
1255
1268
|
predicate: z(B("workflowName", t), B("controlKey", n), B("mode", "batch")),
|
|
1256
1269
|
order: [{
|
|
@@ -1262,23 +1275,23 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1262
1275
|
projection: void 0
|
|
1263
1276
|
})).map((n) => ({
|
|
1264
1277
|
id: String(n.id),
|
|
1265
|
-
payload:
|
|
1266
|
-
})),
|
|
1278
|
+
payload: A(e, t, n.payload)
|
|
1279
|
+
})), gn = async (e, t, n, r) => {
|
|
1267
1280
|
await e.update("_voltro_workflow_admissions", t, {
|
|
1268
1281
|
executionId: n,
|
|
1269
1282
|
runId: r
|
|
1270
1283
|
});
|
|
1271
|
-
},
|
|
1284
|
+
}, _n = K("_voltro_workflow_watermarks", {
|
|
1272
1285
|
id: H({ prefix: "wfwm" }),
|
|
1273
1286
|
positionAt: J(),
|
|
1274
1287
|
updatedAt: J().default("now")
|
|
1275
|
-
}),
|
|
1288
|
+
}), vn = (e) => {
|
|
1276
1289
|
let t = e instanceof Error ? e.message : String(e);
|
|
1277
1290
|
return t.length > 400 ? `${t.slice(0, 400)}…` : t;
|
|
1278
|
-
},
|
|
1279
|
-
let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => L.
|
|
1280
|
-
let n = R.
|
|
1281
|
-
return L.
|
|
1291
|
+
}, yn = (e) => {
|
|
1292
|
+
let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => L.succeed(e) : (t) => {
|
|
1293
|
+
let n = R.decodeUnknownResult(e.payloadSchema)(t);
|
|
1294
|
+
return L.isSuccess(n) ? L.succeed(n.success) : L.fail(vn(n.failure));
|
|
1282
1295
|
}, s = e.runs.map((e) => ({
|
|
1283
1296
|
run: e,
|
|
1284
1297
|
decoded: o(e.payload)
|
|
@@ -1288,34 +1301,34 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1288
1301
|
}));
|
|
1289
1302
|
for (let o of e.entries) for (let l of e.events) {
|
|
1290
1303
|
if (l.name !== o.event) continue;
|
|
1291
|
-
let u = R.
|
|
1292
|
-
if (L.
|
|
1304
|
+
let u = R.decodeUnknownResult(o.schema)(l.payload);
|
|
1305
|
+
if (L.isFailure(u)) {
|
|
1293
1306
|
r.push({
|
|
1294
1307
|
kind: "event-decode",
|
|
1295
1308
|
workflowName: e.workflowName,
|
|
1296
1309
|
event: o.event,
|
|
1297
1310
|
subject: l.id,
|
|
1298
|
-
detail:
|
|
1311
|
+
detail: vn(u.failure)
|
|
1299
1312
|
});
|
|
1300
1313
|
continue;
|
|
1301
1314
|
}
|
|
1302
|
-
let d = u.
|
|
1303
|
-
if (L.
|
|
1315
|
+
let d = u.success, f = (e) => e.getTime() > l.occurredAt.getTime() ? !1 : o.withinMs === void 0 || l.occurredAt.getTime() - e.getTime() <= o.withinMs, p = (t, n) => {
|
|
1316
|
+
if (L.isFailure(t)) return r.push({
|
|
1304
1317
|
kind: "payload-decode",
|
|
1305
1318
|
workflowName: e.workflowName,
|
|
1306
1319
|
event: o.event,
|
|
1307
1320
|
subject: n,
|
|
1308
|
-
detail: t.
|
|
1321
|
+
detail: t.failure
|
|
1309
1322
|
}), !1;
|
|
1310
1323
|
try {
|
|
1311
|
-
return o.match(d, t.
|
|
1324
|
+
return o.match(d, t.success) === !0;
|
|
1312
1325
|
} catch (t) {
|
|
1313
1326
|
return r.push({
|
|
1314
1327
|
kind: "match-threw",
|
|
1315
1328
|
workflowName: e.workflowName,
|
|
1316
1329
|
event: o.event,
|
|
1317
1330
|
subject: n,
|
|
1318
|
-
detail:
|
|
1331
|
+
detail: vn(t)
|
|
1319
1332
|
}), !1;
|
|
1320
1333
|
}
|
|
1321
1334
|
};
|
|
@@ -1338,33 +1351,33 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1338
1351
|
discards: n,
|
|
1339
1352
|
problems: r
|
|
1340
1353
|
};
|
|
1341
|
-
},
|
|
1354
|
+
}, bn = (e) => {
|
|
1342
1355
|
let t;
|
|
1343
1356
|
for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
|
|
1344
1357
|
return t;
|
|
1345
|
-
},
|
|
1358
|
+
}, xn = "_voltro_workflow_watermarks", Sn = "_voltro_workflow_events", Cn = "cancelOn", wn = 36e5, Tn = 500, En = (e) => {
|
|
1346
1359
|
if (e instanceof Date) return e;
|
|
1347
1360
|
if (typeof e == "number") return new Date(e);
|
|
1348
1361
|
if (typeof e == "string") {
|
|
1349
1362
|
let t = new Date(e);
|
|
1350
1363
|
if (!Number.isNaN(t.getTime())) return t;
|
|
1351
1364
|
}
|
|
1352
|
-
},
|
|
1353
|
-
table:
|
|
1365
|
+
}, Dn = (e) => e instanceof Error ? e.message : String(e), On = async (e, t) => En((await e.query({
|
|
1366
|
+
table: xn,
|
|
1354
1367
|
predicate: B("id", t),
|
|
1355
1368
|
order: [],
|
|
1356
1369
|
take: 1,
|
|
1357
1370
|
skip: void 0,
|
|
1358
1371
|
projection: void 0
|
|
1359
|
-
}))[0]?.positionAt),
|
|
1360
|
-
await e.upsert(
|
|
1372
|
+
}))[0]?.positionAt), kn = async (e, t, n) => {
|
|
1373
|
+
await e.upsert(xn, {
|
|
1361
1374
|
id: t,
|
|
1362
1375
|
positionAt: n,
|
|
1363
1376
|
updatedAt: /* @__PURE__ */ new Date()
|
|
1364
1377
|
}, {
|
|
1365
1378
|
conflictColumns: ["id"],
|
|
1366
1379
|
update: (e) => {
|
|
1367
|
-
let t =
|
|
1380
|
+
let t = En(e.positionAt);
|
|
1368
1381
|
return t !== void 0 && t.getTime() >= n.getTime() ? {
|
|
1369
1382
|
positionAt: t,
|
|
1370
1383
|
updatedAt: /* @__PURE__ */ new Date()
|
|
@@ -1374,7 +1387,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1374
1387
|
};
|
|
1375
1388
|
}
|
|
1376
1389
|
});
|
|
1377
|
-
},
|
|
1390
|
+
}, An = async (e, t, n) => {
|
|
1378
1391
|
let r = async (r) => e.query({
|
|
1379
1392
|
table: "_voltro_workflow_runs",
|
|
1380
1393
|
predicate: z(B("tag", t), B("status", r)),
|
|
@@ -1387,7 +1400,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1387
1400
|
projection: void 0
|
|
1388
1401
|
});
|
|
1389
1402
|
return [...await r("running"), ...await r("suspended")].flatMap((e) => {
|
|
1390
|
-
let t = e, n =
|
|
1403
|
+
let t = e, n = En(t.startedAt);
|
|
1391
1404
|
return typeof t.id != "string" || typeof t.executionId != "string" || n === void 0 ? [] : [{
|
|
1392
1405
|
runId: t.id,
|
|
1393
1406
|
executionId: t.executionId,
|
|
@@ -1395,7 +1408,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1395
1408
|
startedAt: n
|
|
1396
1409
|
}];
|
|
1397
1410
|
});
|
|
1398
|
-
},
|
|
1411
|
+
}, jn = async (e, t, n) => (await e.query({
|
|
1399
1412
|
table: "_voltro_workflow_pending",
|
|
1400
1413
|
predicate: B("workflowName", t),
|
|
1401
1414
|
order: [{
|
|
@@ -1406,13 +1419,13 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1406
1419
|
skip: void 0,
|
|
1407
1420
|
projection: void 0
|
|
1408
1421
|
})).flatMap((e) => {
|
|
1409
|
-
let t = e, n =
|
|
1422
|
+
let t = e, n = En(t.firstSeenAt);
|
|
1410
1423
|
return typeof t.id != "string" || n === void 0 ? [] : [{
|
|
1411
1424
|
intentId: t.id,
|
|
1412
1425
|
payload: t.payload,
|
|
1413
1426
|
firstSeenAt: n
|
|
1414
1427
|
}];
|
|
1415
|
-
}),
|
|
1428
|
+
}), Mn = async (e, t) => {
|
|
1416
1429
|
let n = t.workflows.filter((e) => e.entries.length > 0);
|
|
1417
1430
|
if (n.length === 0) return {
|
|
1418
1431
|
examined: !1,
|
|
@@ -1427,11 +1440,11 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1427
1440
|
};
|
|
1428
1441
|
let r = e.now?.() ?? Date.now(), i = t.batch ?? 500, a = t.coldLookbackMs ?? 36e5, o = /* @__PURE__ */ new Set();
|
|
1429
1442
|
for (let e of n) for (let t of e.entries) o.add(t.event);
|
|
1430
|
-
let s = await
|
|
1431
|
-
s === void 0 && (await
|
|
1443
|
+
let s = await On(e.store, Cn), c = s ?? new Date(r - a);
|
|
1444
|
+
s === void 0 && (await kn(e.store, Cn, c), s = c);
|
|
1432
1445
|
let l = await e.store.query({
|
|
1433
|
-
table:
|
|
1434
|
-
predicate:
|
|
1446
|
+
table: Sn,
|
|
1447
|
+
predicate: ot("occurredAt", c),
|
|
1435
1448
|
order: [{
|
|
1436
1449
|
column: "occurredAt",
|
|
1437
1450
|
direction: "asc"
|
|
@@ -1441,7 +1454,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1441
1454
|
projection: void 0
|
|
1442
1455
|
}), u = [];
|
|
1443
1456
|
for (let e of l) {
|
|
1444
|
-
let t = e, n =
|
|
1457
|
+
let t = e, n = En(t.occurredAt);
|
|
1445
1458
|
typeof t.id == "string" && typeof t.name == "string" && n !== void 0 && o.has(t.name) && u.push({
|
|
1446
1459
|
id: t.id,
|
|
1447
1460
|
name: t.name,
|
|
@@ -1455,15 +1468,15 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1455
1468
|
if (n.length === 0) continue;
|
|
1456
1469
|
let r = [], i = [];
|
|
1457
1470
|
try {
|
|
1458
|
-
r = await
|
|
1471
|
+
r = await An(e.store, t.workflowName, _), i = await jn(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
|
|
1459
1472
|
} catch (e) {
|
|
1460
1473
|
f.push({
|
|
1461
1474
|
subject: t.workflowName,
|
|
1462
|
-
detail:
|
|
1475
|
+
detail: Dn(e)
|
|
1463
1476
|
}), g = !0;
|
|
1464
1477
|
continue;
|
|
1465
1478
|
}
|
|
1466
|
-
let a =
|
|
1479
|
+
let a = yn({
|
|
1467
1480
|
workflowName: t.workflowName,
|
|
1468
1481
|
entries: t.entries,
|
|
1469
1482
|
payloadSchema: t.payloadSchema,
|
|
@@ -1485,7 +1498,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1485
1498
|
} catch (e) {
|
|
1486
1499
|
f.push({
|
|
1487
1500
|
subject: n.runId,
|
|
1488
|
-
detail:
|
|
1501
|
+
detail: Dn(e)
|
|
1489
1502
|
}), g = !0;
|
|
1490
1503
|
}
|
|
1491
1504
|
for (let n of a.discards) try {
|
|
@@ -1496,18 +1509,18 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1496
1509
|
} catch (e) {
|
|
1497
1510
|
f.push({
|
|
1498
1511
|
subject: n.intentId,
|
|
1499
|
-
detail:
|
|
1512
|
+
detail: Dn(e)
|
|
1500
1513
|
}), g = !0;
|
|
1501
1514
|
}
|
|
1502
1515
|
}
|
|
1503
|
-
let v =
|
|
1516
|
+
let v = bn(u), ee = s;
|
|
1504
1517
|
if (g) e.log?.warn("workflow.cancelOn: holding the watermark — evaluation or delivery remains incomplete", { failures: f.length });
|
|
1505
1518
|
else if (v !== void 0) try {
|
|
1506
|
-
await
|
|
1519
|
+
await kn(e.store, Cn, v), ee = v;
|
|
1507
1520
|
} catch (e) {
|
|
1508
1521
|
f.push({
|
|
1509
|
-
subject:
|
|
1510
|
-
detail:
|
|
1522
|
+
subject: Cn,
|
|
1523
|
+
detail: Dn(e)
|
|
1511
1524
|
});
|
|
1512
1525
|
}
|
|
1513
1526
|
return d.length > 0 && e.log?.warn("workflow.cancelOn: some events could not be evaluated", {
|
|
@@ -1522,16 +1535,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1522
1535
|
sawFullRunPage: h,
|
|
1523
1536
|
problems: d,
|
|
1524
1537
|
failures: f,
|
|
1525
|
-
watermark:
|
|
1538
|
+
watermark: ee
|
|
1526
1539
|
};
|
|
1527
|
-
},
|
|
1540
|
+
}, Nn = 18e5, Pn = 200, Fn = 20, In = (e) => {
|
|
1528
1541
|
if (e instanceof Date) return e;
|
|
1529
1542
|
if (typeof e == "number") return new Date(e);
|
|
1530
1543
|
if (typeof e == "string") {
|
|
1531
1544
|
let t = new Date(e);
|
|
1532
1545
|
if (!Number.isNaN(t.getTime())) return t;
|
|
1533
1546
|
}
|
|
1534
|
-
},
|
|
1547
|
+
}, Ln = (e) => e instanceof Error ? e.message : String(e), Rn = async (e, t, n) => (await e.query({
|
|
1535
1548
|
table: "_voltro_workflow_run_events",
|
|
1536
1549
|
predicate: B("runId", t),
|
|
1537
1550
|
order: [{
|
|
@@ -1542,13 +1555,13 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1542
1555
|
skip: void 0,
|
|
1543
1556
|
projection: void 0
|
|
1544
1557
|
})).flatMap((e) => {
|
|
1545
|
-
let t = e, n =
|
|
1558
|
+
let t = e, n = In(t.occurredAt);
|
|
1546
1559
|
return typeof t.eventType != "string" || n === void 0 ? [] : [{
|
|
1547
1560
|
eventType: t.eventType,
|
|
1548
1561
|
occurredAt: n,
|
|
1549
1562
|
payload: t.payload
|
|
1550
1563
|
}];
|
|
1551
|
-
}),
|
|
1564
|
+
}), zn = async (e, t) => {
|
|
1552
1565
|
let n = (await e.query({
|
|
1553
1566
|
table: "_voltro_workflow_run_steps",
|
|
1554
1567
|
predicate: B("runId", t),
|
|
@@ -1561,24 +1574,24 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1561
1574
|
projection: void 0
|
|
1562
1575
|
}))[0];
|
|
1563
1576
|
if (n === void 0) return;
|
|
1564
|
-
let r =
|
|
1577
|
+
let r = In(n.startedAt), i = In(n.completedAt);
|
|
1565
1578
|
return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
|
|
1566
|
-
},
|
|
1579
|
+
}, Bn = (e, t) => {
|
|
1567
1580
|
for (let n of e) {
|
|
1568
1581
|
if (n.eventType === "timer-fired") return !1;
|
|
1569
1582
|
if (n.eventType !== "timer-set") continue;
|
|
1570
|
-
let e =
|
|
1583
|
+
let e = In(n.payload?.scheduledWakeAt);
|
|
1571
1584
|
return e !== void 0 && e.getTime() > t;
|
|
1572
1585
|
}
|
|
1573
1586
|
return !1;
|
|
1574
|
-
},
|
|
1587
|
+
}, Vn = (e, t) => {
|
|
1575
1588
|
if (e !== "suspended") return "no-progress";
|
|
1576
1589
|
for (let e of t) {
|
|
1577
1590
|
if (e.eventType === "signal-received" || e.eventType === "signal-sent") return "suspended";
|
|
1578
1591
|
if (e.eventType === "signal-awaited") return "awaiting-signal";
|
|
1579
1592
|
}
|
|
1580
1593
|
return "suspended";
|
|
1581
|
-
},
|
|
1594
|
+
}, Hn = async (e, t = {}) => {
|
|
1582
1595
|
let n = e.now?.() ?? Date.now(), r = t.stallAfterMs ?? 18e5, i = t.runPage ?? 200, a = t.eventLookback ?? 20, o = new Date(n - r), s = [], c = [], l = 0, u = 0, d, f;
|
|
1583
1596
|
try {
|
|
1584
1597
|
if (!Number.isSafeInteger(i) || i < 1) throw Error("Staleness run page must be a positive integer");
|
|
@@ -1586,7 +1599,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1586
1599
|
if (n !== void 0 && (!(n.startedAt instanceof Date) || !Number.isFinite(n.startedAt.getTime()) || typeof n.runId != "string" || n.runId.length === 0)) throw Error("Invalid staleness run cursor");
|
|
1587
1600
|
d = await e.store.query({
|
|
1588
1601
|
table: "_voltro_workflow_runs",
|
|
1589
|
-
predicate: z(
|
|
1602
|
+
predicate: z(st("status", ["running", "suspended"]), lt("startedAt", o), ...n === void 0 ? [] : [ut(V("startedAt", n.startedAt), z(B("startedAt", n.startedAt), V("id", n.runId)))]),
|
|
1590
1603
|
order: [{
|
|
1591
1604
|
column: "startedAt",
|
|
1592
1605
|
direction: "asc"
|
|
@@ -1600,7 +1613,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1600
1613
|
});
|
|
1601
1614
|
let r = n;
|
|
1602
1615
|
for (let e of d) {
|
|
1603
|
-
let t =
|
|
1616
|
+
let t = In(e.startedAt);
|
|
1604
1617
|
if (t === void 0 || !Number.isFinite(t.getTime()) || typeof e.id != "string" || e.id.length === 0) throw Error("Staleness candidate has no valid pagination identity");
|
|
1605
1618
|
if (r !== void 0 && (t.getTime() < r.startedAt.getTime() || t.getTime() === r.startedAt.getTime() && e.id <= r.runId)) throw Error("Staleness candidate page did not advance");
|
|
1606
1619
|
r = {
|
|
@@ -1618,24 +1631,24 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1618
1631
|
sawFullRunPage: !1,
|
|
1619
1632
|
failures: [{
|
|
1620
1633
|
subject: "_voltro_workflow_runs",
|
|
1621
|
-
detail:
|
|
1634
|
+
detail: Ln(e)
|
|
1622
1635
|
}]
|
|
1623
1636
|
};
|
|
1624
1637
|
}
|
|
1625
1638
|
for (let t of d) {
|
|
1626
|
-
let i = t, o =
|
|
1639
|
+
let i = t, o = In(i.startedAt);
|
|
1627
1640
|
if (typeof i.id != "string" || typeof i.tag != "string" || typeof i.executionId != "string" || typeof i.status != "string" || o === void 0) continue;
|
|
1628
1641
|
let d, f;
|
|
1629
1642
|
try {
|
|
1630
|
-
d = await
|
|
1643
|
+
d = await Rn(e.store, i.id, a), f = await zn(e.store, i.id);
|
|
1631
1644
|
} catch (e) {
|
|
1632
1645
|
s.push({
|
|
1633
1646
|
subject: i.id,
|
|
1634
|
-
detail:
|
|
1647
|
+
detail: Ln(e)
|
|
1635
1648
|
});
|
|
1636
1649
|
continue;
|
|
1637
1650
|
}
|
|
1638
|
-
if (
|
|
1651
|
+
if (Bn(d, n)) {
|
|
1639
1652
|
u += 1;
|
|
1640
1653
|
continue;
|
|
1641
1654
|
}
|
|
@@ -1654,7 +1667,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1654
1667
|
status: i.status,
|
|
1655
1668
|
lastProgressAt: m,
|
|
1656
1669
|
idleMs: h,
|
|
1657
|
-
reason:
|
|
1670
|
+
reason: Vn(i.status, d)
|
|
1658
1671
|
};
|
|
1659
1672
|
c.push(g);
|
|
1660
1673
|
let _ = {};
|
|
@@ -1663,7 +1676,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1663
1676
|
} catch (e) {
|
|
1664
1677
|
s.push({
|
|
1665
1678
|
subject: `${g.runId}:describeRun`,
|
|
1666
|
-
detail:
|
|
1679
|
+
detail: Ln(e)
|
|
1667
1680
|
});
|
|
1668
1681
|
}
|
|
1669
1682
|
if (e.log?.warn("workflow.staleness: run has made no progress", {
|
|
@@ -1689,7 +1702,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1689
1702
|
} catch (e) {
|
|
1690
1703
|
s.push({
|
|
1691
1704
|
subject: g.runId,
|
|
1692
|
-
detail:
|
|
1705
|
+
detail: Ln(e)
|
|
1693
1706
|
});
|
|
1694
1707
|
}
|
|
1695
1708
|
if (e.onStalled !== void 0) try {
|
|
@@ -1697,7 +1710,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1697
1710
|
} catch (e) {
|
|
1698
1711
|
s.push({
|
|
1699
1712
|
subject: `${g.runId}:onStalled`,
|
|
1700
|
-
detail:
|
|
1713
|
+
detail: Ln(e)
|
|
1701
1714
|
});
|
|
1702
1715
|
}
|
|
1703
1716
|
}
|
|
@@ -1710,8 +1723,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1710
1723
|
failures: s,
|
|
1711
1724
|
...f === void 0 ? {} : { nextRun: f }
|
|
1712
1725
|
};
|
|
1713
|
-
},
|
|
1714
|
-
let r = await e.transaction((e) =>
|
|
1726
|
+
}, Un = async (e, t, n) => {
|
|
1727
|
+
let r = await e.transaction((e) => C(e, t.id));
|
|
1715
1728
|
if (r === void 0 || r.workflowName !== t.workflowName || r.tenantId !== t.tenantId || r.ledgerId !== t.ledgerId) throw Error("Submission dispatch lost its resident owner");
|
|
1716
1729
|
if (!r.receiptsBound || r.failureId !== null) throw Error("Cannot dispatch an incomplete or rejected submission");
|
|
1717
1730
|
if (r.preparedExecutionId !== null) {
|
|
@@ -1719,26 +1732,26 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1719
1732
|
return r.preparedExecutionId;
|
|
1720
1733
|
}
|
|
1721
1734
|
if (r.dispatchAttempts !== 0 || r.executionId !== null) throw Error("Submission has an unbound prior dispatch; reconciliation required");
|
|
1722
|
-
let i = await e.resolveExecutionId(t.workflowName, n), a = await e.transaction((e) =>
|
|
1735
|
+
let i = await e.resolveExecutionId(t.workflowName, n), a = await e.transaction((e) => w(e, t.id, i));
|
|
1723
1736
|
if (a.preparedExecutionId === null) throw Error("Submission preparation returned no execution identity");
|
|
1724
1737
|
return a.preparedExecutionId;
|
|
1725
|
-
},
|
|
1726
|
-
let i =
|
|
1738
|
+
}, Wn = /* @__PURE__ */ new WeakMap(), Gn = async (e, t, n, r) => {
|
|
1739
|
+
let i = Wn.get(e), a = await me(e.store, n, i?.afterId), o = 0, s = 0, c = 0, l = 0, u = i?.nextDueAt, f = (e) => {
|
|
1727
1740
|
u = Math.min(u ?? e, e);
|
|
1728
1741
|
};
|
|
1729
1742
|
for (let n of a) {
|
|
1730
1743
|
let i;
|
|
1731
1744
|
try {
|
|
1732
|
-
i =
|
|
1745
|
+
i = De(n);
|
|
1733
1746
|
} catch {
|
|
1734
|
-
o++, c++,
|
|
1747
|
+
o++, c++, f(t + Re(1)), e.log?.warn?.("workflow submission metadata is invalid", { submissionId: typeof n.id == "string" ? n.id : null });
|
|
1735
1748
|
continue;
|
|
1736
1749
|
}
|
|
1737
1750
|
o++;
|
|
1738
1751
|
let a = i.dispatchAttempts === 0 ? 0 : void 0;
|
|
1739
1752
|
try {
|
|
1740
1753
|
let n = i.preparedExecutionId, r = n === null || i.dispatchAttempts === 0 ? void 0 : await e.transaction(async (e) => {
|
|
1741
|
-
let t = await
|
|
1754
|
+
let t = await de(e, i.workflowName, n);
|
|
1742
1755
|
return t === void 0 ? void 0 : {
|
|
1743
1756
|
executionId: n,
|
|
1744
1757
|
runId: t.runId
|
|
@@ -1749,15 +1762,15 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1749
1762
|
continue;
|
|
1750
1763
|
}
|
|
1751
1764
|
if (r === void 0 && i.retry.after > t) {
|
|
1752
|
-
o--,
|
|
1765
|
+
o--, f(i.retry.after);
|
|
1753
1766
|
continue;
|
|
1754
1767
|
}
|
|
1755
1768
|
if (r === void 0 && e.acquireSubmissionCapacity !== void 0 && !await e.acquireSubmissionCapacity(i)) {
|
|
1756
|
-
|
|
1769
|
+
f(t + 1e3);
|
|
1757
1770
|
continue;
|
|
1758
1771
|
}
|
|
1759
1772
|
let c = r ?? await (async () => {
|
|
1760
|
-
let n = e.controls.get(i.workflowName)?.batch === void 0 ?
|
|
1773
|
+
let n = e.controls.get(i.workflowName)?.batch === void 0 ? A(e.store, i.workflowName, i.payload) : { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(i.payload).items.map((t) => A(e.store, i.workflowName, t)) }, r = await Un(e, i, n), o = await e.transaction((e) => Ge(e, i.id, t));
|
|
1761
1774
|
if (o === null) return;
|
|
1762
1775
|
a = o.dispatchAttempts === 1 ? 1 : void 0;
|
|
1763
1776
|
let s = await e.startAdmitted(i.workflowName, n, i.callerContext, r);
|
|
@@ -1773,7 +1786,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1773
1786
|
source: "flow-control",
|
|
1774
1787
|
mode: "singleton"
|
|
1775
1788
|
}
|
|
1776
|
-
}), await
|
|
1789
|
+
}), await ze(e.store, i.eviction.executionId, t)), await e.transaction((e) => Ve(e, i.id, {
|
|
1777
1790
|
executionId: c.executionId,
|
|
1778
1791
|
runId: c.runId ?? null
|
|
1779
1792
|
})), s++;
|
|
@@ -1782,7 +1795,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1782
1795
|
let o;
|
|
1783
1796
|
try {
|
|
1784
1797
|
if (a !== void 0 && e.isPermanentStartError?.(n) === !0) {
|
|
1785
|
-
let r = a, o = await e.transaction((a) =>
|
|
1798
|
+
let r = a, o = await e.transaction((a) => Ne(a, i.id, r, {
|
|
1786
1799
|
handler: e.controls.get(i.workflowName)?.onFailure ?? null,
|
|
1787
1800
|
errorMessage: String(n),
|
|
1788
1801
|
now: t
|
|
@@ -1796,28 +1809,28 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1796
1809
|
continue;
|
|
1797
1810
|
}
|
|
1798
1811
|
}
|
|
1799
|
-
o = await e.transaction((e) =>
|
|
1812
|
+
o = await e.transaction((e) => re(e, i.id, String(n), t, r));
|
|
1800
1813
|
} catch (r) {
|
|
1801
|
-
|
|
1814
|
+
f(t), e.log?.warn?.("workflow submission retry state could not be recorded", {
|
|
1802
1815
|
workflow: i.workflowName,
|
|
1803
1816
|
submissionId: i.id,
|
|
1804
|
-
cause:
|
|
1817
|
+
cause: d(i.workflowName, n),
|
|
1805
1818
|
recordingCause: String(r)
|
|
1806
1819
|
});
|
|
1807
1820
|
continue;
|
|
1808
1821
|
}
|
|
1809
|
-
o.retry.stoppedAt === null &&
|
|
1822
|
+
o.retry.stoppedAt === null && f(o.retry.after), e.log?.warn?.("workflow submission remains unacknowledged", {
|
|
1810
1823
|
workflow: i.workflowName,
|
|
1811
1824
|
submissionId: i.id,
|
|
1812
|
-
cause:
|
|
1825
|
+
cause: d(i.workflowName, n),
|
|
1813
1826
|
retryStoppedAt: o.retry.stoppedAt,
|
|
1814
1827
|
acceptance: "unknown"
|
|
1815
1828
|
});
|
|
1816
1829
|
}
|
|
1817
1830
|
}
|
|
1818
|
-
let
|
|
1819
|
-
return a.length === n &&
|
|
1820
|
-
afterId:
|
|
1831
|
+
let p = a.at(-1);
|
|
1832
|
+
return a.length === n && p !== void 0 && typeof p.id == "string" ? (Wn.set(e, {
|
|
1833
|
+
afterId: p.id,
|
|
1821
1834
|
nextDueAt: u
|
|
1822
1835
|
}), {
|
|
1823
1836
|
scanned: o,
|
|
@@ -1826,7 +1839,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1826
1839
|
rejected: l,
|
|
1827
1840
|
nextDueAt: t,
|
|
1828
1841
|
examined: !0
|
|
1829
|
-
}) : (
|
|
1842
|
+
}) : (Wn.delete(e), {
|
|
1830
1843
|
scanned: o,
|
|
1831
1844
|
admitted: s,
|
|
1832
1845
|
failed: c,
|
|
@@ -1834,10 +1847,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1834
1847
|
nextDueAt: u,
|
|
1835
1848
|
examined: a.length > 0
|
|
1836
1849
|
});
|
|
1837
|
-
},
|
|
1838
|
-
let r =
|
|
1839
|
-
table:
|
|
1840
|
-
predicate: z(
|
|
1850
|
+
}, Kn = /* @__PURE__ */ new WeakMap(), qn = async (e, t, n) => {
|
|
1851
|
+
let r = Kn.get(e), i = await e.store.query({
|
|
1852
|
+
table: he,
|
|
1853
|
+
predicate: z(ct("handler"), W("acceptedExecutionId"), ...r === void 0 ? [] : [V("id", r.afterId)]),
|
|
1841
1854
|
order: [{
|
|
1842
1855
|
column: "id",
|
|
1843
1856
|
direction: "asc"
|
|
@@ -1846,21 +1859,21 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1846
1859
|
skip: void 0,
|
|
1847
1860
|
projection: void 0
|
|
1848
1861
|
}), a = 0, o = !1, s = r?.nextDueAt, c = () => {
|
|
1849
|
-
let e = t +
|
|
1862
|
+
let e = t + Re(1, () => 1);
|
|
1850
1863
|
s = Math.min(s ?? e, e);
|
|
1851
1864
|
};
|
|
1852
1865
|
for (let n of i) try {
|
|
1853
1866
|
if (typeof n.id != "string" || n.id.length === 0) throw Error("Failure report has no identity");
|
|
1854
1867
|
let r = n.id;
|
|
1855
|
-
(await e.transaction((e) =>
|
|
1868
|
+
(await e.transaction((e) => le(e, r, t))).kind === "queued" && (o = !0, c());
|
|
1856
1869
|
} catch (t) {
|
|
1857
1870
|
a++, c(), e.log?.warn?.("workflow failure delivery could not be reconciled", {
|
|
1858
1871
|
failureId: typeof n.id == "string" ? n.id : null,
|
|
1859
|
-
...t instanceof
|
|
1872
|
+
...t instanceof fe ? { reason: t.reason } : {}
|
|
1860
1873
|
});
|
|
1861
1874
|
}
|
|
1862
1875
|
let l = i.at(-1);
|
|
1863
|
-
return i.length === n && l !== void 0 && typeof l.id == "string" ? (
|
|
1876
|
+
return i.length === n && l !== void 0 && typeof l.id == "string" ? (Kn.set(e, {
|
|
1864
1877
|
afterId: l.id,
|
|
1865
1878
|
nextDueAt: s
|
|
1866
1879
|
}), {
|
|
@@ -1869,16 +1882,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1869
1882
|
hasPending: o,
|
|
1870
1883
|
nextDueAt: t,
|
|
1871
1884
|
examined: !0
|
|
1872
|
-
}) : (
|
|
1885
|
+
}) : (Kn.delete(e), {
|
|
1873
1886
|
scanned: i.length,
|
|
1874
1887
|
failed: a,
|
|
1875
1888
|
hasPending: o,
|
|
1876
1889
|
nextDueAt: s,
|
|
1877
1890
|
examined: i.length > 0
|
|
1878
1891
|
});
|
|
1879
|
-
},
|
|
1880
|
-
let r =
|
|
1881
|
-
table:
|
|
1892
|
+
}, Jn = "_voltro_workflow_parent_closures", Yn = /* @__PURE__ */ new WeakMap(), Xn = async (e, t, n) => {
|
|
1893
|
+
let r = Yn.get(e), i = await e.store.query({
|
|
1894
|
+
table: Jn,
|
|
1882
1895
|
predicate: z(W("completedAt"), ...r === void 0 ? [] : [V("id", r.afterId)]),
|
|
1883
1896
|
order: [{
|
|
1884
1897
|
column: "id",
|
|
@@ -1894,9 +1907,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1894
1907
|
if (typeof n.id != "string" || n.id.length === 0) throw Error("Parent closure has no identity");
|
|
1895
1908
|
let r = n.id;
|
|
1896
1909
|
await e.transaction(async (e) => {
|
|
1897
|
-
await
|
|
1910
|
+
await Rt(e, r, t);
|
|
1898
1911
|
let [n] = await e.query({
|
|
1899
|
-
table:
|
|
1912
|
+
table: Jn,
|
|
1900
1913
|
predicate: B("id", r),
|
|
1901
1914
|
order: [],
|
|
1902
1915
|
take: 1,
|
|
@@ -1910,7 +1923,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1910
1923
|
a++, s(), e.log?.warn?.("workflow parent closure could not be reconciled", { closureId: typeof n.id == "string" ? n.id : null });
|
|
1911
1924
|
}
|
|
1912
1925
|
let c = i.at(-1);
|
|
1913
|
-
return i.length === n && typeof c?.id == "string" ? (
|
|
1926
|
+
return i.length === n && typeof c?.id == "string" ? (Yn.set(e, {
|
|
1914
1927
|
afterId: c.id,
|
|
1915
1928
|
nextDueAt: o
|
|
1916
1929
|
}), {
|
|
@@ -1918,16 +1931,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1918
1931
|
failed: a,
|
|
1919
1932
|
nextDueAt: t,
|
|
1920
1933
|
examined: !0
|
|
1921
|
-
}) : (
|
|
1934
|
+
}) : (Yn.delete(e), {
|
|
1922
1935
|
scanned: i.length,
|
|
1923
1936
|
failed: a,
|
|
1924
1937
|
nextDueAt: o,
|
|
1925
1938
|
examined: i.length > 0
|
|
1926
1939
|
});
|
|
1927
|
-
},
|
|
1940
|
+
}, Zn = async (e, t) => {
|
|
1928
1941
|
if (t.from === t.to) throw Error("Queue transfer requires distinct source and target");
|
|
1929
1942
|
let n = await e.query({
|
|
1930
|
-
table:
|
|
1943
|
+
table: T,
|
|
1931
1944
|
predicate: B("id", t.to),
|
|
1932
1945
|
order: [],
|
|
1933
1946
|
take: 1,
|
|
@@ -1940,7 +1953,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1940
1953
|
if (r.workflowName !== t.workflowName || r.tenantId !== t.tenantId) throw Error("Receipt target belongs to a different workflow or tenant");
|
|
1941
1954
|
for (;;) {
|
|
1942
1955
|
let n = await e.query({
|
|
1943
|
-
table:
|
|
1956
|
+
table: Le,
|
|
1944
1957
|
predicate: z(B("pendingId", t.from), W("submissionId"), W("terminal")),
|
|
1945
1958
|
order: [{
|
|
1946
1959
|
column: "id",
|
|
@@ -1952,12 +1965,12 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1952
1965
|
});
|
|
1953
1966
|
if (n.length === 0) return;
|
|
1954
1967
|
for (let r of n) {
|
|
1955
|
-
let n =
|
|
1968
|
+
let n = Pe(r);
|
|
1956
1969
|
if (n.workflowName !== t.workflowName || n.tenantId !== t.tenantId) throw Error("Forwarded receipt belongs to a different workflow or tenant");
|
|
1957
1970
|
if (await e.update("_voltro_workflow_start_receipts", n.id, { pendingId: t.to }) === null) throw Error("Start receipt disappeared during queue transfer");
|
|
1958
1971
|
}
|
|
1959
1972
|
}
|
|
1960
|
-
},
|
|
1973
|
+
}, Qn = {
|
|
1961
1974
|
scanned: 0,
|
|
1962
1975
|
admitted: 0,
|
|
1963
1976
|
deferred: 0,
|
|
@@ -1969,77 +1982,77 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
1969
1982
|
deadLettered: 0,
|
|
1970
1983
|
timedOut: 0,
|
|
1971
1984
|
examined: !1
|
|
1972
|
-
},
|
|
1985
|
+
}, $n = 200, er = class extends Error {
|
|
1973
1986
|
submissionId;
|
|
1974
1987
|
rejected;
|
|
1975
1988
|
constructor(e, t, n = !1) {
|
|
1976
1989
|
super(n ? `Submission ${e} rejected; failure report retained` : `Submission ${e} remains unacknowledged`, { cause: t }), this.submissionId = e, this.rejected = n;
|
|
1977
1990
|
}
|
|
1978
|
-
},
|
|
1979
|
-
let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200,
|
|
1991
|
+
}, tr = (e) => e instanceof er && !e.rejected, nr = async (e, t = {}) => {
|
|
1992
|
+
let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, o, s, c, l, u, f;
|
|
1980
1993
|
try {
|
|
1981
|
-
|
|
1982
|
-
let r = t.skipPending === !0 && !
|
|
1994
|
+
l = await Gn(e, n(), i, e.deadLetterAfterAttempts ?? 50), u = await qn(e, n(), i), f = await Xn(e, n(), i), o = await (e.readPauses?.() ?? ne(e.store));
|
|
1995
|
+
let r = t.skipPending === !0 && !u.hasPending ? {
|
|
1983
1996
|
due: [],
|
|
1984
1997
|
nextDueAt: void 0
|
|
1985
|
-
} : await
|
|
1986
|
-
|
|
1998
|
+
} : await Ce(e.store, n(), i);
|
|
1999
|
+
s = r.due, c = l.nextDueAt === void 0 ? r.nextDueAt : Math.min(r.nextDueAt ?? l.nextDueAt, l.nextDueAt), u.nextDueAt !== void 0 && (c = Math.min(c ?? u.nextDueAt, u.nextDueAt)), f.nextDueAt !== void 0 && (c = Math.min(c ?? f.nextDueAt, f.nextDueAt));
|
|
1987
2000
|
} catch (e) {
|
|
1988
2001
|
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), {
|
|
1989
|
-
...
|
|
1990
|
-
scanned: (
|
|
1991
|
-
admitted:
|
|
1992
|
-
deadLettered:
|
|
1993
|
-
failed: (
|
|
2002
|
+
...Qn,
|
|
2003
|
+
scanned: (l?.scanned ?? 0) + (u?.scanned ?? 0) + (f?.scanned ?? 0),
|
|
2004
|
+
admitted: l?.admitted ?? 0,
|
|
2005
|
+
deadLettered: l?.rejected ?? 0,
|
|
2006
|
+
failed: (l?.failed ?? 0) + (u?.failed ?? 0) + (f?.failed ?? 0) + 1,
|
|
1994
2007
|
nextDueAt: n()
|
|
1995
2008
|
};
|
|
1996
2009
|
}
|
|
1997
|
-
let
|
|
1998
|
-
scanned:
|
|
1999
|
-
admitted:
|
|
2010
|
+
let p = {
|
|
2011
|
+
scanned: s.length + l.scanned + u.scanned + f.scanned,
|
|
2012
|
+
admitted: l.admitted,
|
|
2000
2013
|
deferred: 0,
|
|
2001
2014
|
dropped: 0,
|
|
2002
2015
|
skipped: 0,
|
|
2003
2016
|
expired: 0,
|
|
2004
2017
|
evicted: 0,
|
|
2005
|
-
failed:
|
|
2006
|
-
deadLettered:
|
|
2018
|
+
failed: l.failed + u.failed + f.failed,
|
|
2019
|
+
deadLettered: l.rejected,
|
|
2007
2020
|
timedOut: 0
|
|
2008
|
-
},
|
|
2009
|
-
for (let e of
|
|
2021
|
+
}, m = /* @__PURE__ */ new Map(), h = [];
|
|
2022
|
+
for (let e of s) {
|
|
2010
2023
|
if (e.mode === "batch") {
|
|
2011
|
-
let t = `${e.workflowName}\u0000${e.controlKey}`, n =
|
|
2012
|
-
n === void 0 ?
|
|
2024
|
+
let t = `${e.workflowName}\u0000${e.controlKey}`, n = m.get(t);
|
|
2025
|
+
n === void 0 ? m.set(t, [e]) : n.push(e);
|
|
2013
2026
|
continue;
|
|
2014
2027
|
}
|
|
2015
|
-
|
|
2028
|
+
h.push(e);
|
|
2016
2029
|
}
|
|
2017
|
-
let
|
|
2030
|
+
let g = e.deadLetterAfterAttempts === void 0 ? 50 : e.deadLetterAfterAttempts, _ = (t, n, r) => {
|
|
2018
2031
|
if (e.isPermanentStartError?.(n) === !0) return `pending ${r} was dead-lettered after a permanent start failure: ${String(n)}`;
|
|
2019
|
-
if (
|
|
2032
|
+
if (g !== !1 && t.attempts + 1 >= g) return `pending ${r} was dead-lettered after ${t.attempts + 1} failed attempts: ${String(n)}`;
|
|
2020
2033
|
};
|
|
2021
|
-
for (let t of
|
|
2022
|
-
await
|
|
2034
|
+
for (let t of h) try {
|
|
2035
|
+
await or(e, t, o, p, n());
|
|
2023
2036
|
} catch (i) {
|
|
2024
|
-
if (
|
|
2025
|
-
i.rejected &&
|
|
2037
|
+
if (p.failed++, i instanceof er) {
|
|
2038
|
+
i.rejected && p.deadLettered++, r?.warn?.(i.message, {
|
|
2026
2039
|
submissionId: i.submissionId,
|
|
2027
|
-
cause:
|
|
2040
|
+
cause: d(t.workflowName, i.cause)
|
|
2028
2041
|
});
|
|
2029
2042
|
continue;
|
|
2030
2043
|
}
|
|
2031
|
-
let a =
|
|
2044
|
+
let a = _(t, i, "intent");
|
|
2032
2045
|
if (a !== void 0) {
|
|
2033
2046
|
let o = n(), s = String(i);
|
|
2034
|
-
if (await
|
|
2047
|
+
if (await ir(e, [t], a, s, o, !1).catch((e) => (r?.warn?.("workflow flow control: intent could not be dead-lettered with its report", {
|
|
2035
2048
|
workflow: t.workflowName,
|
|
2036
2049
|
intent: t.id,
|
|
2037
2050
|
cause: String(e)
|
|
2038
2051
|
}), 0)) > 0) {
|
|
2039
|
-
|
|
2052
|
+
p.deadLettered++, r?.warn?.("workflow flow control: intent dead-lettered", {
|
|
2040
2053
|
workflow: t.workflowName,
|
|
2041
2054
|
intent: t.id,
|
|
2042
|
-
cause:
|
|
2055
|
+
cause: d(t.workflowName, s)
|
|
2043
2056
|
});
|
|
2044
2057
|
continue;
|
|
2045
2058
|
}
|
|
@@ -2047,48 +2060,48 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2047
2060
|
r?.warn?.("workflow flow control: an intent failed to drain", {
|
|
2048
2061
|
workflow: t.workflowName,
|
|
2049
2062
|
intent: t.id,
|
|
2050
|
-
cause:
|
|
2051
|
-
}), await
|
|
2063
|
+
cause: d(t.workflowName, i)
|
|
2064
|
+
}), await oe(e.store, t, String(i), n()).catch(() => {});
|
|
2052
2065
|
}
|
|
2053
|
-
for (let t of
|
|
2054
|
-
await
|
|
2066
|
+
for (let t of m.values()) try {
|
|
2067
|
+
await cr(e, t, o, p, n());
|
|
2055
2068
|
} catch (i) {
|
|
2056
|
-
if (
|
|
2057
|
-
i.rejected &&
|
|
2069
|
+
if (p.failed++, i instanceof er) {
|
|
2070
|
+
i.rejected && p.deadLettered++, r?.warn?.(i.message, {
|
|
2058
2071
|
submissionId: i.submissionId,
|
|
2059
|
-
cause:
|
|
2072
|
+
cause: d(t[0]?.workflowName, i.cause)
|
|
2060
2073
|
});
|
|
2061
2074
|
continue;
|
|
2062
2075
|
}
|
|
2063
|
-
let
|
|
2064
|
-
if (
|
|
2065
|
-
let
|
|
2066
|
-
if (await
|
|
2067
|
-
workflow:
|
|
2076
|
+
let o = t[0], s = o === void 0 ? void 0 : _(o, i, "batch");
|
|
2077
|
+
if (o !== void 0 && s !== void 0) {
|
|
2078
|
+
let a = n(), c = String(i);
|
|
2079
|
+
if (await ir(e, t, s, c, a, !0).catch((e) => (r?.warn?.("workflow flow control: batch could not be dead-lettered with its report", {
|
|
2080
|
+
workflow: o.workflowName,
|
|
2068
2081
|
intents: t.map((e) => e.id),
|
|
2069
2082
|
size: t.length,
|
|
2070
2083
|
cause: String(e)
|
|
2071
2084
|
}), 0)) === t.length) {
|
|
2072
|
-
|
|
2073
|
-
workflow:
|
|
2085
|
+
p.deadLettered += t.length, r?.warn?.("workflow flow control: batch dead-lettered", {
|
|
2086
|
+
workflow: o.workflowName,
|
|
2074
2087
|
intents: t.map((e) => e.id),
|
|
2075
2088
|
size: t.length,
|
|
2076
|
-
cause:
|
|
2089
|
+
cause: d(o.workflowName, c)
|
|
2077
2090
|
});
|
|
2078
2091
|
continue;
|
|
2079
2092
|
}
|
|
2080
2093
|
}
|
|
2081
2094
|
r?.warn?.("workflow flow control: a batch failed to drain", {
|
|
2082
|
-
workflow:
|
|
2095
|
+
workflow: o?.workflowName,
|
|
2083
2096
|
size: t.length,
|
|
2084
|
-
cause:
|
|
2097
|
+
cause: d(o?.workflowName, i)
|
|
2085
2098
|
});
|
|
2086
|
-
let
|
|
2099
|
+
let c = n(), l = Math.random();
|
|
2087
2100
|
await e.transaction(async (e) => {
|
|
2088
2101
|
let n = [];
|
|
2089
2102
|
for (let r of t) {
|
|
2090
2103
|
let t = await e.query({
|
|
2091
|
-
table:
|
|
2104
|
+
table: T,
|
|
2092
2105
|
predicate: B("id", r.id),
|
|
2093
2106
|
order: [],
|
|
2094
2107
|
take: 1,
|
|
@@ -2097,39 +2110,39 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2097
2110
|
lock: "update"
|
|
2098
2111
|
});
|
|
2099
2112
|
if (t[0] === void 0) return;
|
|
2100
|
-
let i =
|
|
2113
|
+
let i = j(t[0]);
|
|
2101
2114
|
if (i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.mode !== r.mode || i.firstSeenAt !== r.firstSeenAt || i.dueAt !== r.dueAt || i.deadLetteredAt !== void 0) return;
|
|
2102
2115
|
n.push(i);
|
|
2103
2116
|
}
|
|
2104
|
-
let r = new Date(
|
|
2117
|
+
let r = new Date(c + Re(Math.max(...n.map((e) => e.attempts + 1)), () => l));
|
|
2105
2118
|
for (let t of n) if (await e.update("_voltro_workflow_pending", t.id, {
|
|
2106
2119
|
attempts: t.attempts + 1,
|
|
2107
|
-
lastError:
|
|
2120
|
+
lastError: a(t.workflowName, String(i).slice(0, 500)),
|
|
2108
2121
|
dueAt: r,
|
|
2109
|
-
updatedAt: new Date(
|
|
2122
|
+
updatedAt: new Date(c)
|
|
2110
2123
|
}) === null) throw Error("Batch input disappeared while recording the shared retry deadline");
|
|
2111
2124
|
}).catch((e) => r?.warn?.("workflow flow control: batch retry could not be persisted", {
|
|
2112
|
-
workflow:
|
|
2125
|
+
workflow: o?.workflowName,
|
|
2113
2126
|
intents: t.map((e) => e.id),
|
|
2114
2127
|
cause: String(e)
|
|
2115
2128
|
}));
|
|
2116
2129
|
}
|
|
2117
|
-
let
|
|
2118
|
-
return
|
|
2119
|
-
...
|
|
2120
|
-
examined: t.skipPending !== !0 ||
|
|
2121
|
-
...
|
|
2130
|
+
let v = await fr(e, n()).catch(() => ({ cancelled: 0 }));
|
|
2131
|
+
return p.timedOut = v.cancelled, v.nextDeadlineAt !== void 0 && (c === void 0 || v.nextDeadlineAt < c) && (c = v.nextDeadlineAt), {
|
|
2132
|
+
...p,
|
|
2133
|
+
examined: t.skipPending !== !0 || l.examined || u.examined || f.examined,
|
|
2134
|
+
...c === void 0 ? {} : { nextDueAt: c }
|
|
2122
2135
|
};
|
|
2123
|
-
},
|
|
2136
|
+
}, rr = async (e, t, n) => {
|
|
2124
2137
|
let r = t.map((e) => ({
|
|
2125
2138
|
intent: e,
|
|
2126
|
-
failureId: `wff_${
|
|
2139
|
+
failureId: `wff_${_t()}`
|
|
2127
2140
|
}));
|
|
2128
2141
|
return e.transaction(async (e) => {
|
|
2129
2142
|
let t = 0;
|
|
2130
2143
|
for (let { intent: i, failureId: a } of r) {
|
|
2131
2144
|
let r = (await e.query({
|
|
2132
|
-
table:
|
|
2145
|
+
table: T,
|
|
2133
2146
|
predicate: B("id", i.id),
|
|
2134
2147
|
order: [],
|
|
2135
2148
|
take: 1,
|
|
@@ -2138,11 +2151,11 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2138
2151
|
lock: "update"
|
|
2139
2152
|
}))[0];
|
|
2140
2153
|
if (r === void 0) continue;
|
|
2141
|
-
let o =
|
|
2154
|
+
let o = j(r);
|
|
2142
2155
|
if (o.workflowName !== i.workflowName || o.tenantId !== i.tenantId) throw Error("Abandoned queue selection belongs to another workflow or tenant");
|
|
2143
2156
|
if (o.dueAt > n || o.deadLetteredAt !== void 0) continue;
|
|
2144
2157
|
let s = `workflow '${o.workflowName}' no longer has its queued declaration`;
|
|
2145
|
-
if (await
|
|
2158
|
+
if (await S(e, {
|
|
2146
2159
|
id: a,
|
|
2147
2160
|
sourceKind: "intent",
|
|
2148
2161
|
sourceId: o.id,
|
|
@@ -2174,13 +2187,13 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2174
2187
|
}
|
|
2175
2188
|
return t;
|
|
2176
2189
|
});
|
|
2177
|
-
},
|
|
2178
|
-
let o = `wff_${
|
|
2190
|
+
}, ir = async (e, t, n, r, i, a) => {
|
|
2191
|
+
let o = `wff_${_t()}`;
|
|
2179
2192
|
return e.transaction(async (s) => {
|
|
2180
2193
|
let c = [];
|
|
2181
2194
|
for (let e of t) {
|
|
2182
2195
|
let t = await s.query({
|
|
2183
|
-
table:
|
|
2196
|
+
table: T,
|
|
2184
2197
|
predicate: B("id", e.id),
|
|
2185
2198
|
order: [],
|
|
2186
2199
|
take: 1,
|
|
@@ -2189,17 +2202,17 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2189
2202
|
lock: "update"
|
|
2190
2203
|
});
|
|
2191
2204
|
if (t[0] === void 0) return 0;
|
|
2192
|
-
let n =
|
|
2205
|
+
let n = j(t[0]);
|
|
2193
2206
|
if (n.workflowName !== e.workflowName || n.tenantId !== e.tenantId) throw Error("Dead-letter selection belongs to another workflow or tenant");
|
|
2194
2207
|
if (n.deadLetteredAt !== void 0) return 0;
|
|
2195
2208
|
c.push(n);
|
|
2196
2209
|
}
|
|
2197
2210
|
let l = c[0];
|
|
2198
2211
|
if (l === void 0) return 0;
|
|
2199
|
-
let u = await Promise.all(c.map((e) =>
|
|
2212
|
+
let u = await Promise.all(c.map((e) => ce(s, e.id)));
|
|
2200
2213
|
if (u.some(Boolean) && !u.every(Boolean)) throw Error("Dead-lettered batch mixes failure delivery and ordinary callers; reconciliation required");
|
|
2201
2214
|
let d = e.controls.get(l.workflowName);
|
|
2202
|
-
await
|
|
2215
|
+
await S(s, {
|
|
2203
2216
|
id: o,
|
|
2204
2217
|
sourceKind: "intent",
|
|
2205
2218
|
sourceId: l.id,
|
|
@@ -2227,16 +2240,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2227
2240
|
at: i,
|
|
2228
2241
|
failureId: o
|
|
2229
2242
|
}
|
|
2230
|
-
}), !await
|
|
2231
|
-
return await
|
|
2243
|
+
}), !await O(s, e, r, i)) throw Error("Dead-lettered queue row disappeared before marking");
|
|
2244
|
+
return await k(s, o, i), c.length;
|
|
2232
2245
|
});
|
|
2233
|
-
},
|
|
2234
|
-
let a = `wff_${
|
|
2246
|
+
}, ar = async (e, t, n, r, i) => {
|
|
2247
|
+
let a = `wff_${_t()}`;
|
|
2235
2248
|
return e.transaction(async (e) => {
|
|
2236
2249
|
let o = [];
|
|
2237
2250
|
for (let i of t) {
|
|
2238
2251
|
let t = await e.query({
|
|
2239
|
-
table:
|
|
2252
|
+
table: T,
|
|
2240
2253
|
predicate: B("id", i.id),
|
|
2241
2254
|
order: [],
|
|
2242
2255
|
take: 1,
|
|
@@ -2245,18 +2258,18 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2245
2258
|
lock: "update"
|
|
2246
2259
|
});
|
|
2247
2260
|
if (t[0] === void 0) return 0;
|
|
2248
|
-
let a =
|
|
2261
|
+
let a = j(t[0]);
|
|
2249
2262
|
if (a.workflowName !== n.workflowName || a.tenantId !== i.tenantId) throw Error("Expired queue selection belongs to another workflow or tenant");
|
|
2250
2263
|
if (a.mode !== i.mode || a.dueAt > r || a.deadLetteredAt !== void 0) return 0;
|
|
2251
2264
|
o.push(a);
|
|
2252
2265
|
}
|
|
2253
2266
|
o.sort((e, t) => e.firstSeenAt - t.firstSeenAt || e.id.localeCompare(t.id));
|
|
2254
2267
|
let s = o[0];
|
|
2255
|
-
if (s === void 0 || !
|
|
2256
|
-
let c = await Promise.all(o.map((t) =>
|
|
2268
|
+
if (s === void 0 || !se(n, s, r)) return 0;
|
|
2269
|
+
let c = await Promise.all(o.map((t) => ce(e, t.id)));
|
|
2257
2270
|
if (c.some(Boolean) && !c.every(Boolean)) throw Error("Expired batch mixes failure delivery and ordinary callers; reconciliation required");
|
|
2258
2271
|
let l = `timeouts.start (${n.timeouts?.startMs}ms) elapsed while ${o.length} queued input(s) waited`;
|
|
2259
|
-
await
|
|
2272
|
+
await S(e, {
|
|
2260
2273
|
id: a,
|
|
2261
2274
|
sourceKind: "intent",
|
|
2262
2275
|
sourceId: s.id,
|
|
@@ -2274,10 +2287,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2274
2287
|
runId: null,
|
|
2275
2288
|
executionId: null
|
|
2276
2289
|
}
|
|
2277
|
-
}), await
|
|
2290
|
+
}), await M({
|
|
2278
2291
|
store: e,
|
|
2279
2292
|
control: n,
|
|
2280
|
-
keys: D(n,
|
|
2293
|
+
keys: D(n, A(e, s.workflowName, s.payload)),
|
|
2281
2294
|
outcome: "expired",
|
|
2282
2295
|
mode: s.mode,
|
|
2283
2296
|
reason: l,
|
|
@@ -2298,23 +2311,23 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2298
2311
|
failureId: a
|
|
2299
2312
|
}
|
|
2300
2313
|
}), !await e.delete("_voltro_workflow_pending", t.id)) throw Error("Expired queue row disappeared before deletion");
|
|
2301
|
-
return await
|
|
2314
|
+
return await k(e, a, r), o.length;
|
|
2302
2315
|
});
|
|
2303
|
-
},
|
|
2316
|
+
}, or = async (e, t, n, r, i) => {
|
|
2304
2317
|
if (t = {
|
|
2305
2318
|
...t,
|
|
2306
|
-
payload:
|
|
2307
|
-
}, t.mode === "delayed") return
|
|
2319
|
+
payload: A(e.store, t.workflowName, t.payload)
|
|
2320
|
+
}, t.mode === "delayed") return sr(e, t, n, r, i);
|
|
2308
2321
|
let a = e.controls.get(t.workflowName);
|
|
2309
2322
|
if (a === void 0) {
|
|
2310
|
-
r.expired += await
|
|
2323
|
+
r.expired += await rr(e, [t], i);
|
|
2311
2324
|
return;
|
|
2312
2325
|
}
|
|
2313
|
-
if (
|
|
2314
|
-
r.expired += await
|
|
2326
|
+
if (se(a, t, i)) {
|
|
2327
|
+
r.expired += await ar(e, [t], a, i, !1);
|
|
2315
2328
|
return;
|
|
2316
2329
|
}
|
|
2317
|
-
let o = D(a, t.payload), s = await
|
|
2330
|
+
let o = D(a, t.payload), s = await be({
|
|
2318
2331
|
store: e.store,
|
|
2319
2332
|
control: a,
|
|
2320
2333
|
keys: o,
|
|
@@ -2322,7 +2335,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2322
2335
|
now: i,
|
|
2323
2336
|
reconsidering: !0
|
|
2324
2337
|
});
|
|
2325
|
-
await
|
|
2338
|
+
await lr(e, {
|
|
2326
2339
|
control: a,
|
|
2327
2340
|
intent: t,
|
|
2328
2341
|
decision: s,
|
|
@@ -2332,14 +2345,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2332
2345
|
paused: n,
|
|
2333
2346
|
items: void 0
|
|
2334
2347
|
});
|
|
2335
|
-
},
|
|
2348
|
+
}, sr = async (e, t, n, r, i) => {
|
|
2336
2349
|
if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
|
|
2337
|
-
r.expired += await
|
|
2350
|
+
r.expired += await rr(e, [t], i);
|
|
2338
2351
|
return;
|
|
2339
2352
|
}
|
|
2340
|
-
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o =
|
|
2353
|
+
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = ge(), s = await e.transaction(async (e) => {
|
|
2341
2354
|
let r = await e.query({
|
|
2342
|
-
table:
|
|
2355
|
+
table: T,
|
|
2343
2356
|
predicate: B("id", t.id),
|
|
2344
2357
|
lock: "update",
|
|
2345
2358
|
order: [],
|
|
@@ -2348,31 +2361,31 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2348
2361
|
projection: void 0
|
|
2349
2362
|
});
|
|
2350
2363
|
if (r[0] === void 0) return;
|
|
2351
|
-
let s =
|
|
2364
|
+
let s = j(r[0]);
|
|
2352
2365
|
if (s.workflowName !== t.workflowName || s.tenantId !== t.tenantId) throw Error("Delayed arrival belongs to a different workflow or tenant");
|
|
2353
2366
|
if (s.mode !== "delayed" || s.deadLetteredAt !== void 0 || s.dueAt > i) return;
|
|
2354
|
-
let c = await
|
|
2367
|
+
let c = await mn({
|
|
2355
2368
|
store: e,
|
|
2356
2369
|
control: a,
|
|
2357
|
-
payload:
|
|
2370
|
+
payload: A(e, s.workflowName, s.payload),
|
|
2358
2371
|
callerContext: s.callerContext,
|
|
2359
2372
|
tenantId: s.tenantId,
|
|
2360
2373
|
paused: n.has(s.workflowName),
|
|
2361
2374
|
now: i,
|
|
2362
2375
|
waiting: !1
|
|
2363
2376
|
});
|
|
2364
|
-
if (c.kind === "queued" && (await
|
|
2377
|
+
if (c.kind === "queued" && (await Zn(e, {
|
|
2365
2378
|
from: s.id,
|
|
2366
2379
|
to: c.intentId,
|
|
2367
2380
|
workflowName: s.workflowName,
|
|
2368
2381
|
tenantId: s.tenantId
|
|
2369
|
-
}), !await
|
|
2382
|
+
}), !await Ke(e, s.id))) throw Error("Delayed arrival disappeared during queue transfer");
|
|
2370
2383
|
if (c.kind === "start") {
|
|
2371
2384
|
if (c.ledgerId === void 0) throw Error("Delayed arrival has no admission reservation");
|
|
2372
2385
|
let t = a.batch === void 0 ? ye(e, s.workflowName, c.payload) : { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(c.payload).items.map((t) => ye(e, s.workflowName, t)) };
|
|
2373
2386
|
return {
|
|
2374
2387
|
kind: "submission",
|
|
2375
|
-
submission: await
|
|
2388
|
+
submission: await dn(e, {
|
|
2376
2389
|
id: o,
|
|
2377
2390
|
workflowName: s.workflowName,
|
|
2378
2391
|
tenantId: s.tenantId,
|
|
@@ -2393,7 +2406,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2393
2406
|
...c,
|
|
2394
2407
|
at: i
|
|
2395
2408
|
}
|
|
2396
|
-
}), !await
|
|
2409
|
+
}), !await Ke(e, s.id))) throw Error("Delayed arrival disappeared while recording its outcome");
|
|
2397
2410
|
return c;
|
|
2398
2411
|
});
|
|
2399
2412
|
if (s !== void 0) {
|
|
@@ -2409,30 +2422,30 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2409
2422
|
r.skipped++;
|
|
2410
2423
|
return;
|
|
2411
2424
|
}
|
|
2412
|
-
await
|
|
2425
|
+
await dr(e, s.submission, a, r, i, a.batch !== void 0, s.keys);
|
|
2413
2426
|
}
|
|
2414
|
-
},
|
|
2427
|
+
}, cr = async (e, t, n, r, i) => {
|
|
2415
2428
|
t = t.map((t) => ({
|
|
2416
2429
|
...t,
|
|
2417
|
-
payload:
|
|
2430
|
+
payload: A(e.store, t.workflowName, t.payload)
|
|
2418
2431
|
}));
|
|
2419
2432
|
let a = t[0];
|
|
2420
2433
|
if (a === void 0) return;
|
|
2421
2434
|
let o = e.controls.get(a.workflowName);
|
|
2422
2435
|
if (o === void 0 || o.batch === void 0) {
|
|
2423
|
-
r.expired += await
|
|
2436
|
+
r.expired += await rr(e, t, i);
|
|
2424
2437
|
return;
|
|
2425
2438
|
}
|
|
2426
2439
|
let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
|
|
2427
|
-
if (
|
|
2428
|
-
r.expired += await
|
|
2440
|
+
if (se(o, c, i)) {
|
|
2441
|
+
r.expired += await ar(e, s, o, i, !0);
|
|
2429
2442
|
return;
|
|
2430
2443
|
}
|
|
2431
2444
|
let l = D(o, c.payload);
|
|
2432
|
-
await
|
|
2445
|
+
await lr(e, {
|
|
2433
2446
|
control: o,
|
|
2434
2447
|
intent: c,
|
|
2435
|
-
decision: await
|
|
2448
|
+
decision: await be({
|
|
2436
2449
|
store: e.store,
|
|
2437
2450
|
control: o,
|
|
2438
2451
|
keys: l,
|
|
@@ -2446,10 +2459,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2446
2459
|
paused: n,
|
|
2447
2460
|
items: s
|
|
2448
2461
|
});
|
|
2449
|
-
},
|
|
2462
|
+
}, lr = async (e, t) => {
|
|
2450
2463
|
let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c, paused: l } = t;
|
|
2451
2464
|
if (i.kind === "defer") {
|
|
2452
|
-
await
|
|
2465
|
+
await Se({
|
|
2453
2466
|
store: e.store,
|
|
2454
2467
|
control: n,
|
|
2455
2468
|
decision: i,
|
|
@@ -2466,7 +2479,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2466
2479
|
let t = [];
|
|
2467
2480
|
for (let i of c ?? [r]) {
|
|
2468
2481
|
let a = await e.query({
|
|
2469
|
-
table:
|
|
2482
|
+
table: T,
|
|
2470
2483
|
predicate: B("id", i.id),
|
|
2471
2484
|
lock: "update",
|
|
2472
2485
|
order: [],
|
|
@@ -2475,17 +2488,17 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2475
2488
|
projection: void 0
|
|
2476
2489
|
});
|
|
2477
2490
|
if (a[0] === void 0) return;
|
|
2478
|
-
let o =
|
|
2491
|
+
let o = j(a[0]);
|
|
2479
2492
|
if (o.workflowName !== n.workflowName || o.tenantId !== r.tenantId) throw Error("Terminal queue selection belongs to a different workflow or tenant");
|
|
2480
2493
|
if (o.dueAt > s || o.deadLetteredAt !== void 0 || o.mode !== i.mode) return;
|
|
2481
2494
|
t.push(o);
|
|
2482
2495
|
}
|
|
2483
2496
|
t.sort((e, t) => e.firstSeenAt - t.firstSeenAt);
|
|
2484
|
-
let i = t[0], a = D(n,
|
|
2497
|
+
let i = t[0], a = D(n, A(e, n.workflowName, i.payload)), o = await be({
|
|
2485
2498
|
store: e,
|
|
2486
2499
|
control: n,
|
|
2487
2500
|
keys: a,
|
|
2488
|
-
paused: l.has(n.workflowName) || (await
|
|
2501
|
+
paused: l.has(n.workflowName) || (await ne(e)).has(n.workflowName),
|
|
2489
2502
|
now: s,
|
|
2490
2503
|
reconsidering: !0
|
|
2491
2504
|
});
|
|
@@ -2500,7 +2513,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2500
2513
|
executionId: o.incumbent.executionId,
|
|
2501
2514
|
runId: o.incumbent.runId
|
|
2502
2515
|
};
|
|
2503
|
-
await
|
|
2516
|
+
await M({
|
|
2504
2517
|
store: e,
|
|
2505
2518
|
control: n,
|
|
2506
2519
|
keys: a,
|
|
@@ -2519,20 +2532,20 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2519
2532
|
workflowName: n.workflowName,
|
|
2520
2533
|
tenantId: n.tenantId,
|
|
2521
2534
|
terminal: u
|
|
2522
|
-
}), !await
|
|
2535
|
+
}), !await Ke(e, n.id)) throw Error("Queued input disappeared while recording its terminal outcome");
|
|
2523
2536
|
return u.kind;
|
|
2524
2537
|
});
|
|
2525
2538
|
t !== void 0 && o[t]++;
|
|
2526
2539
|
return;
|
|
2527
2540
|
}
|
|
2528
|
-
let u =
|
|
2541
|
+
let u = ge(), d = await e.transaction((t) => pn(t, {
|
|
2529
2542
|
id: u,
|
|
2530
2543
|
workflowName: n.workflowName,
|
|
2531
2544
|
tenantId: r.tenantId,
|
|
2532
2545
|
intentIds: (c ?? [r]).map((e) => e.id),
|
|
2533
2546
|
now: s,
|
|
2534
2547
|
prepare: (t) => {
|
|
2535
|
-
let r = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), i = r[0], a =
|
|
2548
|
+
let r = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), i = r[0], a = A(e.store, n.workflowName, i.payload);
|
|
2536
2549
|
return {
|
|
2537
2550
|
control: n,
|
|
2538
2551
|
keyPayload: a,
|
|
@@ -2550,16 +2563,16 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2550
2563
|
o.deferred++;
|
|
2551
2564
|
return;
|
|
2552
2565
|
}
|
|
2553
|
-
await
|
|
2566
|
+
await dr(e, d.submission, n, o, s, c !== void 0, a);
|
|
2554
2567
|
}
|
|
2555
|
-
},
|
|
2556
|
-
let a = await e.transaction((e) =>
|
|
2568
|
+
}, ur = async (e, t, n, r, i) => {
|
|
2569
|
+
let a = await e.transaction((e) => C(e, t.id));
|
|
2557
2570
|
if (a === void 0 || !a.receiptsBound || a.workflowName !== n.workflowName || a.workflowName !== t.workflowName || a.tenantId !== t.tenantId || a.ledgerId !== t.ledgerId) throw Error("Admission acceptance callback no longer has its resident submission owner");
|
|
2558
2571
|
if (a.executionId !== null) {
|
|
2559
2572
|
if (a.failureId !== null || a.executionId.length === 0 || a.executionId !== a.preparedExecutionId) throw Error("Admission acceptance has contradictory resident execution evidence");
|
|
2560
2573
|
return a.executionId;
|
|
2561
2574
|
}
|
|
2562
|
-
await
|
|
2575
|
+
await dr(e, a, n, {
|
|
2563
2576
|
admitted: 0,
|
|
2564
2577
|
deferred: 0,
|
|
2565
2578
|
dropped: 0,
|
|
@@ -2567,17 +2580,17 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2567
2580
|
expired: 0,
|
|
2568
2581
|
evicted: 0
|
|
2569
2582
|
}, i, n.batch !== void 0, r);
|
|
2570
|
-
let o = await e.transaction((e) =>
|
|
2583
|
+
let o = await e.transaction((e) => C(e, t.id));
|
|
2571
2584
|
if (o?.executionId == null || o.executionId !== o.preparedExecutionId) throw Error("Admission submission has no confirmed engine acceptance");
|
|
2572
2585
|
return o.executionId;
|
|
2573
|
-
},
|
|
2586
|
+
}, dr = async (e, t, n, r, i, a, o) => {
|
|
2574
2587
|
let s = t.dispatchAttempts === 0 ? 0 : void 0;
|
|
2575
2588
|
try {
|
|
2576
2589
|
if (e.acquireSubmissionCapacity !== void 0 && !await e.acquireSubmissionCapacity(t)) {
|
|
2577
2590
|
r.deferred++;
|
|
2578
2591
|
return;
|
|
2579
2592
|
}
|
|
2580
|
-
let c = a ? { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(t.payload).items.map((t) =>
|
|
2593
|
+
let c = a ? { items: R.decodeUnknownSync(R.Struct({ items: R.Array(R.Unknown) }))(t.payload).items.map((t) => A(e.store, n.workflowName, t)) } : A(e.store, n.workflowName, t.payload), l = await Un(e, t, c), u = await e.transaction((e) => Ge(e, t.id, i));
|
|
2581
2594
|
if (u === null) return;
|
|
2582
2595
|
s = u.dispatchAttempts === 1 ? 1 : void 0;
|
|
2583
2596
|
let d = await e.startAdmitted(n.workflowName, c, t.callerContext, l);
|
|
@@ -2591,7 +2604,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2591
2604
|
source: "flow-control",
|
|
2592
2605
|
mode: "singleton"
|
|
2593
2606
|
}
|
|
2594
|
-
}), await
|
|
2607
|
+
}), await ze(e.store, t.eviction.executionId, i), await M({
|
|
2595
2608
|
store: e.store,
|
|
2596
2609
|
control: n,
|
|
2597
2610
|
keys: o,
|
|
@@ -2604,7 +2617,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2604
2617
|
runId: t.eviction.runId || null,
|
|
2605
2618
|
tenantId: t.tenantId,
|
|
2606
2619
|
now: i
|
|
2607
|
-
}), r.evicted++), await e.transaction((e) =>
|
|
2620
|
+
}), r.evicted++), await e.transaction((e) => Ve(e, t.id, {
|
|
2608
2621
|
executionId: d.executionId,
|
|
2609
2622
|
runId: d.runId ?? null
|
|
2610
2623
|
})), r.admitted++;
|
|
@@ -2613,14 +2626,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2613
2626
|
try {
|
|
2614
2627
|
if (s !== void 0 && e.isPermanentStartError?.(r) === !0) {
|
|
2615
2628
|
let o = s;
|
|
2616
|
-
a = await e.transaction((e) =>
|
|
2629
|
+
a = await e.transaction((e) => Ne(e, t.id, o, {
|
|
2617
2630
|
handler: n.onFailure ?? null,
|
|
2618
2631
|
errorMessage: String(r),
|
|
2619
2632
|
now: i
|
|
2620
2633
|
})) !== void 0;
|
|
2621
2634
|
}
|
|
2622
2635
|
if (!a) {
|
|
2623
|
-
let n = await e.transaction((n) =>
|
|
2636
|
+
let n = await e.transaction((n) => re(n, t.id, String(r), i, e.deadLetterAfterAttempts ?? 50));
|
|
2624
2637
|
n.retry.stoppedAt !== null && e.log?.warn?.("workflow submission automatic retry stopped; engine acceptance unknown", {
|
|
2625
2638
|
submissionId: t.id,
|
|
2626
2639
|
workflow: t.workflowName,
|
|
@@ -2628,18 +2641,18 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2628
2641
|
});
|
|
2629
2642
|
}
|
|
2630
2643
|
} catch (e) {
|
|
2631
|
-
throw new
|
|
2644
|
+
throw new er(t.id, AggregateError([r, e], "Submission and retry recording failed"));
|
|
2632
2645
|
}
|
|
2633
|
-
throw new
|
|
2646
|
+
throw new er(t.id, r, a);
|
|
2634
2647
|
}
|
|
2635
|
-
},
|
|
2648
|
+
}, fr = async (e, t) => {
|
|
2636
2649
|
if (e.listRunningRuns === void 0) return { cancelled: 0 };
|
|
2637
2650
|
let n = 0, r;
|
|
2638
2651
|
for (let i of e.controls.values()) {
|
|
2639
2652
|
if (i.timeouts?.finishMs === void 0) continue;
|
|
2640
2653
|
let a = await e.listRunningRuns(i.workflowName);
|
|
2641
2654
|
for (let o of a) {
|
|
2642
|
-
if (!
|
|
2655
|
+
if (!xe(i, {
|
|
2643
2656
|
startedAt: o.startedAt,
|
|
2644
2657
|
terminal: !1
|
|
2645
2658
|
}, t)) {
|
|
@@ -2654,153 +2667,153 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2654
2667
|
executionId: o.executionId,
|
|
2655
2668
|
reason: a,
|
|
2656
2669
|
detail: {
|
|
2657
|
-
...
|
|
2670
|
+
...Ee,
|
|
2658
2671
|
onFailure: i.onFailure ?? null
|
|
2659
2672
|
}
|
|
2660
|
-
}) && (await
|
|
2673
|
+
}) && (await ze(e.store, o.executionId, t), n++);
|
|
2661
2674
|
}
|
|
2662
2675
|
}
|
|
2663
2676
|
return {
|
|
2664
2677
|
cancelled: n,
|
|
2665
2678
|
...r === void 0 ? {} : { nextDeadlineAt: r }
|
|
2666
2679
|
};
|
|
2667
|
-
},
|
|
2668
|
-
|
|
2669
|
-
},
|
|
2680
|
+
}, pr = 3e5, mr, hr = (e) => {
|
|
2681
|
+
mr = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
|
|
2682
|
+
}, gr = () => {
|
|
2670
2683
|
let e = process.env.VOLTRO_WORKFLOW_SUSPEND_HINT_MS;
|
|
2671
2684
|
if (e !== void 0) {
|
|
2672
2685
|
let t = Number(e);
|
|
2673
2686
|
if (Number.isFinite(t) && t > 0) return t;
|
|
2674
2687
|
}
|
|
2675
|
-
return
|
|
2676
|
-
},
|
|
2677
|
-
|
|
2678
|
-
},
|
|
2679
|
-
let t =
|
|
2688
|
+
return mr ?? 3e5;
|
|
2689
|
+
}, _r = /* @__PURE__ */ new Set(), vr = () => {
|
|
2690
|
+
_r.clear();
|
|
2691
|
+
}, yr = (e) => {
|
|
2692
|
+
let t = gr();
|
|
2680
2693
|
if (!(e.timeoutMs > t)) return !1;
|
|
2681
2694
|
let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
|
|
2682
|
-
if (
|
|
2683
|
-
|
|
2695
|
+
if (_r.has(n)) return !1;
|
|
2696
|
+
_r.add(n);
|
|
2684
2697
|
let r = e.workflowName === void 0 ? "" : ` in workflow '${e.workflowName}'`;
|
|
2685
2698
|
return (e.warn ?? ((e) => console.warn(e)))(`awaitSignal('${e.signalName}')${r} declares a ${Math.round(e.timeoutMs / 1e3)}s timeout — a wait that long holds a worker fiber for its whole duration. For human-approval-length waits, awaitSignalSuspending (same call shape, from @voltro/workflow) SUSPENDS the run and frees the slot until the signal arrives. This is a hint, not a behaviour change; it is logged once per workflow. Threshold: workflows.suspendSignalHintMs in app.config.ts, or VOLTRO_WORKFLOW_SUSPEND_HINT_MS.`), !0;
|
|
2686
|
-
},
|
|
2699
|
+
}, br = async (e, t) => {
|
|
2687
2700
|
if (e) try {
|
|
2688
2701
|
await e.recordEvent(t);
|
|
2689
2702
|
} catch {}
|
|
2690
|
-
},
|
|
2691
|
-
let
|
|
2692
|
-
let
|
|
2693
|
-
|
|
2694
|
-
workflowName:
|
|
2695
|
-
signalName:
|
|
2696
|
-
timeoutMs:
|
|
2703
|
+
}, xr = (e, t) => {
|
|
2704
|
+
let n = F.gen(function* () {
|
|
2705
|
+
let n = t.pollIntervalMs ?? 200, r = t.maxPollIntervalMs ?? 5e3, i = t.timeoutMs ?? 864e5, a = yield* F.serviceOption(Y), o;
|
|
2706
|
+
yr({
|
|
2707
|
+
workflowName: a._tag === "Some" ? a.value.workflow._tag : void 0,
|
|
2708
|
+
signalName: t.name,
|
|
2709
|
+
timeoutMs: i,
|
|
2697
2710
|
warn: (e) => {
|
|
2698
|
-
|
|
2711
|
+
o = e;
|
|
2699
2712
|
}
|
|
2700
|
-
}),
|
|
2701
|
-
let
|
|
2702
|
-
if (
|
|
2703
|
-
let
|
|
2704
|
-
yield*
|
|
2705
|
-
runId:
|
|
2713
|
+
}), o !== void 0 && (yield* F.logWarning(o));
|
|
2714
|
+
let c = yield* h, l = yield* F.serviceOption(y), u = l._tag === "Some" ? l.value : void 0;
|
|
2715
|
+
if (c === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
|
|
2716
|
+
let d = c;
|
|
2717
|
+
yield* F.promise(() => br(u, {
|
|
2718
|
+
runId: d,
|
|
2706
2719
|
eventType: "signal-awaited",
|
|
2707
|
-
payload: { signalName:
|
|
2720
|
+
payload: { signalName: t.name }
|
|
2708
2721
|
}));
|
|
2709
|
-
let
|
|
2722
|
+
let f = Date.now(), p = n;
|
|
2710
2723
|
for (;;) {
|
|
2711
|
-
let
|
|
2712
|
-
if (
|
|
2713
|
-
let
|
|
2724
|
+
let n = Date.now() - f;
|
|
2725
|
+
if (n > i) return yield* F.die(/* @__PURE__ */ Error(`awaitSignal('${t.name}') timed out after ${n}ms`));
|
|
2726
|
+
let a = {
|
|
2714
2727
|
table: "_voltro_workflow_run_events",
|
|
2715
2728
|
order: [{
|
|
2716
2729
|
column: "occurredAt",
|
|
2717
2730
|
direction: "asc"
|
|
2718
2731
|
}],
|
|
2719
|
-
predicate: z(B("runId",
|
|
2732
|
+
predicate: z(B("runId", d), B("eventType", "signal-sent")),
|
|
2720
2733
|
projection: void 0,
|
|
2721
2734
|
skip: void 0,
|
|
2722
2735
|
take: 1e3
|
|
2723
|
-
}, o = (yield*
|
|
2724
|
-
try: () => e.store.query(
|
|
2736
|
+
}, o = (yield* F.tryPromise({
|
|
2737
|
+
try: () => e.store.query(a),
|
|
2725
2738
|
catch: (e) => e
|
|
2726
|
-
})).find((e) => e.payload?.signalName ===
|
|
2739
|
+
})).find((e) => e.payload?.signalName === t.name);
|
|
2727
2740
|
if (o !== void 0) {
|
|
2728
|
-
let e =
|
|
2729
|
-
return yield*
|
|
2730
|
-
runId:
|
|
2741
|
+
let e = s(o.payload)?.value, n = yield* R.decodeUnknownEffect(t.schema)(e);
|
|
2742
|
+
return yield* F.promise(() => br(u, {
|
|
2743
|
+
runId: d,
|
|
2731
2744
|
eventType: "signal-received",
|
|
2732
2745
|
payload: {
|
|
2733
|
-
signalName:
|
|
2746
|
+
signalName: t.name,
|
|
2734
2747
|
value: e
|
|
2735
2748
|
}
|
|
2736
|
-
})),
|
|
2749
|
+
})), n;
|
|
2737
2750
|
}
|
|
2738
|
-
yield*
|
|
2751
|
+
yield* F.sleep(`${p} millis`), p = Math.min(p * 2, r);
|
|
2739
2752
|
}
|
|
2740
2753
|
});
|
|
2741
|
-
return
|
|
2742
|
-
name: `await-signal:${
|
|
2743
|
-
success:
|
|
2744
|
-
execute:
|
|
2754
|
+
return i({
|
|
2755
|
+
name: `await-signal:${t.name}`,
|
|
2756
|
+
success: t.schema,
|
|
2757
|
+
execute: n
|
|
2745
2758
|
});
|
|
2746
|
-
},
|
|
2759
|
+
}, Sr = async (e, t) => {
|
|
2747
2760
|
if (e !== void 0) try {
|
|
2748
2761
|
await e.recordEvent(t);
|
|
2749
2762
|
} catch {}
|
|
2750
|
-
},
|
|
2751
|
-
let
|
|
2752
|
-
let
|
|
2753
|
-
if (
|
|
2754
|
-
let
|
|
2755
|
-
yield*
|
|
2756
|
-
runId:
|
|
2763
|
+
}, Cr = (e, t) => {
|
|
2764
|
+
let n = F.gen(function* () {
|
|
2765
|
+
let n = t.pollIntervalMs ?? 200, r = t.maxPollIntervalMs ?? 5e3, i = t.timeoutMs ?? 864e5, a = t.take ?? 500, o = yield* h, s = yield* F.serviceOption(y), c = s._tag === "Some" ? s.value : void 0;
|
|
2766
|
+
if (o === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
|
|
2767
|
+
let l = o, u = yield* t.since === "run-start" ? wr(e, l) : F.succeed(/* @__PURE__ */ new Date());
|
|
2768
|
+
yield* F.promise(() => Sr(c, {
|
|
2769
|
+
runId: l,
|
|
2757
2770
|
eventType: "event-awaited",
|
|
2758
2771
|
payload: {
|
|
2759
|
-
event:
|
|
2760
|
-
since:
|
|
2761
|
-
cutoff:
|
|
2772
|
+
event: t.event,
|
|
2773
|
+
since: t.since ?? "wait-start",
|
|
2774
|
+
cutoff: u.toISOString()
|
|
2762
2775
|
}
|
|
2763
2776
|
}));
|
|
2764
|
-
let
|
|
2777
|
+
let d = Date.now(), f = n, p = 0;
|
|
2765
2778
|
for (;;) {
|
|
2766
|
-
let
|
|
2767
|
-
if (
|
|
2768
|
-
let
|
|
2779
|
+
let n = Date.now() - d;
|
|
2780
|
+
if (n > i) return yield* F.die(/* @__PURE__ */ Error(`awaitEvent('${t.event}') timed out after ${n}ms having examined ${p} candidate event(s). ${p === 0 ? "NONE were published under that name in the window — check the spelling against ctx.events.publish, and consider since: 'run-start' if the event may have arrived before this step began." : "The predicate rejected all of them — log one payload and compare it with what `match` expects."}`));
|
|
2781
|
+
let o = {
|
|
2769
2782
|
table: "_voltro_workflow_events",
|
|
2770
|
-
predicate: z(B("name",
|
|
2783
|
+
predicate: z(B("name", t.event), ot("occurredAt", u)),
|
|
2771
2784
|
order: [{
|
|
2772
2785
|
column: "occurredAt",
|
|
2773
2786
|
direction: "asc"
|
|
2774
2787
|
}],
|
|
2775
|
-
take:
|
|
2788
|
+
take: a,
|
|
2776
2789
|
skip: void 0,
|
|
2777
2790
|
projection: void 0
|
|
2778
|
-
},
|
|
2779
|
-
try: () => e.store.query(
|
|
2791
|
+
}, s = yield* F.tryPromise({
|
|
2792
|
+
try: () => e.store.query(o),
|
|
2780
2793
|
catch: (e) => e
|
|
2781
2794
|
});
|
|
2782
|
-
|
|
2783
|
-
for (let e of
|
|
2784
|
-
let
|
|
2785
|
-
if (
|
|
2786
|
-
runId:
|
|
2795
|
+
p = s.length;
|
|
2796
|
+
for (let e of s) {
|
|
2797
|
+
let n = yield* R.decodeUnknownEffect(t.schema)(e.payload);
|
|
2798
|
+
if (t.match(n)) return yield* F.promise(() => Sr(c, {
|
|
2799
|
+
runId: l,
|
|
2787
2800
|
eventType: "event-received",
|
|
2788
2801
|
payload: {
|
|
2789
|
-
event:
|
|
2802
|
+
event: t.event,
|
|
2790
2803
|
eventId: e.id
|
|
2791
2804
|
}
|
|
2792
|
-
})),
|
|
2805
|
+
})), n;
|
|
2793
2806
|
}
|
|
2794
|
-
yield*
|
|
2807
|
+
yield* F.sleep(`${f} millis`), f = Math.min(f * 2, r);
|
|
2795
2808
|
}
|
|
2796
2809
|
});
|
|
2797
|
-
return
|
|
2798
|
-
name: `awaitEvent:${
|
|
2799
|
-
success:
|
|
2800
|
-
execute:
|
|
2810
|
+
return i({
|
|
2811
|
+
name: `awaitEvent:${t.event}`,
|
|
2812
|
+
success: t.schema,
|
|
2813
|
+
execute: n
|
|
2801
2814
|
});
|
|
2802
|
-
},
|
|
2803
|
-
let n = (yield*
|
|
2815
|
+
}, wr = (e, t) => F.gen(function* () {
|
|
2816
|
+
let n = (yield* F.tryPromise({
|
|
2804
2817
|
try: () => e.store.query({
|
|
2805
2818
|
table: "_voltro_workflow_runs",
|
|
2806
2819
|
predicate: B("id", t),
|
|
@@ -2817,14 +2830,14 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2817
2830
|
if (!Number.isNaN(e.getTime())) return e;
|
|
2818
2831
|
}
|
|
2819
2832
|
return /* @__PURE__ */ new Date(0);
|
|
2820
|
-
}),
|
|
2833
|
+
}), Tr = Qe.Reference("@voltro/workflow/SuspensionUnavailable", { defaultValue: () => void 0 }), Er = class extends Error {
|
|
2821
2834
|
constructor(e, t) {
|
|
2822
2835
|
super(`${e} cannot wait for a durable result here: ${t}`), this.name = "WorkflowCannotPark";
|
|
2823
2836
|
}
|
|
2824
|
-
},
|
|
2837
|
+
}, Dr = (e) => new Promise((t) => setTimeout(t, e)), Or = () => {
|
|
2825
2838
|
let e = globalThis.crypto;
|
|
2826
2839
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
2827
|
-
},
|
|
2840
|
+
}, kr = () => `wfu_${Or()}`, Ar = async (e, t) => {
|
|
2828
2841
|
let n = t.id ?? t.executionId;
|
|
2829
2842
|
if (!n) throw Error("workflow message target requires target.id or target.executionId");
|
|
2830
2843
|
let r = await e.query({
|
|
@@ -2846,7 +2859,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2846
2859
|
}))[0];
|
|
2847
2860
|
if (!i) throw Error(`workflow message target not found: ${n}`);
|
|
2848
2861
|
return i;
|
|
2849
|
-
},
|
|
2862
|
+
}, jr = class extends Error {
|
|
2850
2863
|
runId;
|
|
2851
2864
|
eventType;
|
|
2852
2865
|
eventId;
|
|
@@ -2854,8 +2867,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2854
2867
|
constructor(e, t, n) {
|
|
2855
2868
|
super(`workflow ${t} for run ${e} was NOT recorded (event ${n}): the run will not see it — the store refused the row, see the recorder's warning`), this.runId = e, this.eventType = t, this.eventId = n, this.name = "WorkflowMessageNotRecorded";
|
|
2856
2869
|
}
|
|
2857
|
-
},
|
|
2858
|
-
let t = await
|
|
2870
|
+
}, Mr = async (e) => {
|
|
2871
|
+
let t = await Ar(e.store, e.target), n = await e.recorder.recordEvent({
|
|
2859
2872
|
runId: t.id,
|
|
2860
2873
|
eventType: "signal-sent",
|
|
2861
2874
|
payload: {
|
|
@@ -2863,10 +2876,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2863
2876
|
value: e.payload
|
|
2864
2877
|
}
|
|
2865
2878
|
});
|
|
2866
|
-
if (n.recorded === !1) throw new
|
|
2879
|
+
if (n.recorded === !1) throw new jr(t.id, "signal-sent", n.id);
|
|
2867
2880
|
return { eventId: n.id };
|
|
2868
|
-
},
|
|
2869
|
-
let t = await
|
|
2881
|
+
}, Nr = async (e) => {
|
|
2882
|
+
let t = await Ar(e.store, e.target), n = kr(), r = await e.recorder.recordEvent({
|
|
2870
2883
|
runId: t.id,
|
|
2871
2884
|
eventType: "update-requested",
|
|
2872
2885
|
payload: {
|
|
@@ -2875,10 +2888,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2875
2888
|
value: e.payload
|
|
2876
2889
|
}
|
|
2877
2890
|
});
|
|
2878
|
-
if (r.recorded === !1) throw new
|
|
2891
|
+
if (r.recorded === !1) throw new jr(t.id, "update-requested", r.id);
|
|
2879
2892
|
let i = Date.now(), a = e.options?.timeoutMs ?? 3e4, o = e.options?.pollIntervalMs ?? 100;
|
|
2880
2893
|
for (;;) {
|
|
2881
|
-
let
|
|
2894
|
+
let c = {
|
|
2882
2895
|
table: "_voltro_workflow_run_events",
|
|
2883
2896
|
order: [{
|
|
2884
2897
|
column: "occurredAt",
|
|
@@ -2888,77 +2901,77 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2888
2901
|
projection: void 0,
|
|
2889
2902
|
skip: void 0,
|
|
2890
2903
|
take: 1e3
|
|
2891
|
-
},
|
|
2892
|
-
if (
|
|
2904
|
+
}, l = await e.store.query(c), u = l.find((e) => e.eventType === "update-completed" && e.payload?.updateId === n);
|
|
2905
|
+
if (u) return {
|
|
2893
2906
|
eventId: r.id,
|
|
2894
2907
|
updateId: n,
|
|
2895
|
-
completedEventId:
|
|
2896
|
-
result:
|
|
2908
|
+
completedEventId: u.id,
|
|
2909
|
+
result: s(u.payload)?.result
|
|
2897
2910
|
};
|
|
2898
|
-
let
|
|
2899
|
-
if (
|
|
2900
|
-
let t = Error(
|
|
2911
|
+
let d = l.find((e) => e.eventType === "update-failed" && e.payload?.updateId === n);
|
|
2912
|
+
if (d) {
|
|
2913
|
+
let t = Error(s(d.payload)?.errorMessage ?? `workflow update '${e.updateName}' failed`);
|
|
2901
2914
|
throw Object.assign(t, {
|
|
2902
2915
|
updateId: n,
|
|
2903
2916
|
eventId: r.id,
|
|
2904
|
-
errorTag:
|
|
2917
|
+
errorTag: d.payload?.errorTag ?? null
|
|
2905
2918
|
}), t;
|
|
2906
2919
|
}
|
|
2907
2920
|
if (Date.now() - i >= a) throw Error(`Timed out waiting for workflow update '${e.updateName}' (${n})`);
|
|
2908
|
-
await
|
|
2921
|
+
await Dr(o);
|
|
2909
2922
|
}
|
|
2910
|
-
},
|
|
2923
|
+
}, Pr = 864e5, Fr = "voltro/suspending-signal", Ir = (e, t) => `${Fr}/${e}/${t}`, Lr = (e, t) => Je.make(e, { success: l(t) ? n(R.Unknown, `signal '${e}' value`) : R.Unknown }), Rr = async (e, t) => {
|
|
2911
2924
|
if (e) try {
|
|
2912
2925
|
await e.recordEvent(t);
|
|
2913
2926
|
} catch {}
|
|
2914
|
-
},
|
|
2915
|
-
let e = yield*
|
|
2916
|
-
if (e !== void 0) return yield*
|
|
2917
|
-
let
|
|
2918
|
-
|
|
2919
|
-
runId:
|
|
2927
|
+
}, zr = (e, t) => F.gen(function* () {
|
|
2928
|
+
let e = yield* Tr;
|
|
2929
|
+
if (e !== void 0) return yield* F.die(new Er(`awaitSignalSuspending('${t.name}')`, e));
|
|
2930
|
+
let n = t.timeoutMs ?? Pr, r = yield* Xe.WorkflowInstance, i = Lr(Ir(r.workflow._tag, t.name), r.workflow._tag), a = yield* h, o = yield* F.serviceOption(y), s = o._tag === "Some" ? o.value : void 0;
|
|
2931
|
+
a !== void 0 && (yield* F.promise(() => Rr(s, {
|
|
2932
|
+
runId: a,
|
|
2920
2933
|
eventType: "signal-awaited",
|
|
2921
|
-
payload: { signalName:
|
|
2934
|
+
payload: { signalName: t.name }
|
|
2922
2935
|
})));
|
|
2923
|
-
let
|
|
2924
|
-
name: `await-signal-timeout/${
|
|
2936
|
+
let c = Je.await(i), l = Number.isFinite(n) ? yield* F.race(c, qe.sleep({
|
|
2937
|
+
name: `await-signal-timeout/${t.name}`,
|
|
2925
2938
|
inMemoryThreshold: "0 millis",
|
|
2926
|
-
duration: `${
|
|
2927
|
-
}).pipe(
|
|
2928
|
-
return
|
|
2929
|
-
runId:
|
|
2939
|
+
duration: `${n} millis`
|
|
2940
|
+
}).pipe(F.andThen(F.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${t.name}') timed out after ${n}ms`))))).pipe(F.catchCause((e) => r.suspended ? P.hasInterruptsOnly(e) ? Ye.suspend(r) : F.failCause(P.fromReasons(e.reasons.filter((e) => !P.isInterruptReason(e)))) : F.failCause(e))) : yield* c, u = yield* R.decodeUnknownEffect(t.schema)(l);
|
|
2941
|
+
return a !== void 0 && (yield* F.promise(() => Rr(s, {
|
|
2942
|
+
runId: a,
|
|
2930
2943
|
eventType: "signal-received",
|
|
2931
2944
|
payload: {
|
|
2932
|
-
signalName:
|
|
2933
|
-
value:
|
|
2945
|
+
signalName: t.name,
|
|
2946
|
+
value: u
|
|
2934
2947
|
}
|
|
2935
|
-
}))),
|
|
2936
|
-
}),
|
|
2948
|
+
}))), u;
|
|
2949
|
+
}), Br = (e) => F.gen(function* () {
|
|
2937
2950
|
let t = e.target.executionId, n = e.target.workflowName;
|
|
2938
2951
|
if (t === void 0 || n === void 0) {
|
|
2939
2952
|
let r = e.store;
|
|
2940
|
-
if (r === void 0) return yield*
|
|
2941
|
-
let i = yield*
|
|
2942
|
-
try: () =>
|
|
2953
|
+
if (r === void 0) return yield* F.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
|
|
2954
|
+
let i = yield* F.tryPromise({
|
|
2955
|
+
try: () => Ar(r, e.target),
|
|
2943
2956
|
catch: (e) => e
|
|
2944
2957
|
});
|
|
2945
2958
|
t ??= i.executionId, n ??= i.tag;
|
|
2946
2959
|
}
|
|
2947
2960
|
if (t === void 0 || n === void 0) return { completed: !1 };
|
|
2948
|
-
let r =
|
|
2961
|
+
let r = Ir(n, e.signalName), i = Lr(r, n), a = new Je.TokenParsed({
|
|
2949
2962
|
workflowName: n,
|
|
2950
2963
|
executionId: t,
|
|
2951
2964
|
deferredName: r
|
|
2952
2965
|
}).asToken;
|
|
2953
|
-
return yield*
|
|
2966
|
+
return yield* Je.done(i, {
|
|
2954
2967
|
token: a,
|
|
2955
|
-
exit:
|
|
2968
|
+
exit: $e.succeed(e.payload)
|
|
2956
2969
|
}), { completed: !0 };
|
|
2957
|
-
}), Z = "_voltro_budget_holds",
|
|
2970
|
+
}), Z = "_voltro_budget_holds", Vr = "budget-hold", Hr = (e) => `${Vr}:${e}`, Ur = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, Wr = async (e, t) => (await e.query({
|
|
2958
2971
|
table: Z,
|
|
2959
2972
|
predicate: z(B("executionId", t.executionId), B("stepName", t.stepName), B("budget", t.budget)),
|
|
2960
2973
|
order: []
|
|
2961
|
-
})).length,
|
|
2974
|
+
})).length, Gr = K(Z, {
|
|
2962
2975
|
id: H({ prefix: "bhd" }),
|
|
2963
2976
|
holdKey: q().maxLength(191).unique(),
|
|
2964
2977
|
budget: q(),
|
|
@@ -2972,35 +2985,35 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
2972
2985
|
heldAt: J().default("now"),
|
|
2973
2986
|
releasedAt: J().nullable(),
|
|
2974
2987
|
outcome: q().nullable()
|
|
2975
|
-
}).index(["budget", "releasedAt"]),
|
|
2976
|
-
|
|
2988
|
+
}).index(["budget", "releasedAt"]), Kr = () => {
|
|
2989
|
+
mt({
|
|
2977
2990
|
source: "framework",
|
|
2978
2991
|
table: Z,
|
|
2979
2992
|
timeColumn: "releasedAt",
|
|
2980
|
-
ttlMs:
|
|
2993
|
+
ttlMs: ht(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
|
|
2981
2994
|
});
|
|
2982
|
-
},
|
|
2995
|
+
}, qr = class extends Error {
|
|
2983
2996
|
budget;
|
|
2984
2997
|
holdKey;
|
|
2985
2998
|
constructor(e, t, n) {
|
|
2986
2999
|
super(`budget '${e}': the run was suspended waiting for headroom and gave up after ${n}ms (hold ${t}). Nothing was spent. Raise the budget, reset its window, or lift the hold, then re-drive the run.`), this.name = "BudgetHoldExpired", this.budget = e, this.holdKey = t;
|
|
2987
3000
|
}
|
|
2988
|
-
},
|
|
2989
|
-
|
|
3001
|
+
}, Jr = 6048e5, Yr = (e) => F.gen(function* () {
|
|
3002
|
+
Kr();
|
|
2990
3003
|
let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
|
|
2991
3004
|
executionId: e.executionId,
|
|
2992
3005
|
stepName: e.stepName,
|
|
2993
3006
|
budget: e.budget
|
|
2994
3007
|
};
|
|
2995
3008
|
for (let i = 0;; i++) {
|
|
2996
|
-
let a = yield*
|
|
3009
|
+
let a = yield* F.promise(() => Zr(e.store, r)), o = a.length === 0 ? Date.now() : Xr(a[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = Ur({
|
|
2997
3010
|
...r,
|
|
2998
3011
|
generation: i
|
|
2999
3012
|
});
|
|
3000
|
-
if (s <= 0) return yield*
|
|
3001
|
-
let l =
|
|
3002
|
-
yield*
|
|
3003
|
-
id:
|
|
3013
|
+
if (s <= 0) return yield* F.promise(() => Qr(e.store, r, "expired")), yield* F.fail(new qr(e.budget, c, t));
|
|
3014
|
+
let l = Hr(c);
|
|
3015
|
+
yield* F.promise(() => e.store.insertIgnore(Z, {
|
|
3016
|
+
id: at({
|
|
3004
3017
|
kind: "typeid",
|
|
3005
3018
|
prefix: "bhd"
|
|
3006
3019
|
}, Z),
|
|
@@ -3018,34 +3031,34 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3018
3031
|
outcome: null
|
|
3019
3032
|
}, { conflictColumns: ["holdKey"] }));
|
|
3020
3033
|
let u = Math.min(n, s);
|
|
3021
|
-
if (yield*
|
|
3034
|
+
if (yield* zr({ store: e.store }, {
|
|
3022
3035
|
name: l,
|
|
3023
3036
|
schema: R.Unknown,
|
|
3024
3037
|
timeoutMs: u
|
|
3025
|
-
}).pipe(
|
|
3038
|
+
}).pipe(F.catchCause((e) => P.hasInterruptsOnly(e) ? F.failCause(e) : F.void)), yield* F.promise(() => e.store.updateMany(Z, {
|
|
3026
3039
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
3027
3040
|
outcome: "recheck"
|
|
3028
3041
|
}, { where: z(B("holdKey", c), W("releasedAt")) })), yield* e.hasHeadroom) return;
|
|
3029
3042
|
}
|
|
3030
|
-
}),
|
|
3043
|
+
}), Xr = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), Zr = async (e, t) => [...await e.query({
|
|
3031
3044
|
table: Z,
|
|
3032
3045
|
predicate: z(B("executionId", t.executionId), B("stepName", t.stepName), B("budget", t.budget)),
|
|
3033
3046
|
order: []
|
|
3034
|
-
})].sort((e, t) => String(e.id).localeCompare(String(t.id))),
|
|
3047
|
+
})].sort((e, t) => String(e.id).localeCompare(String(t.id))), Qr = async (e, t, n) => {
|
|
3035
3048
|
await e.updateMany(Z, {
|
|
3036
3049
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
3037
3050
|
outcome: n
|
|
3038
3051
|
}, { where: z(B("executionId", t.executionId), B("stepName", t.stepName), B("budget", t.budget), W("releasedAt")) });
|
|
3039
|
-
},
|
|
3040
|
-
let t = e.tenantId === void 0 ? z(B("budget", e.budget), W("releasedAt")) : z(B("budget", e.budget), B("tenantId", e.tenantId), W("releasedAt")), n = yield*
|
|
3052
|
+
}, $r = (e) => F.gen(function* () {
|
|
3053
|
+
let t = e.tenantId === void 0 ? z(B("budget", e.budget), W("releasedAt")) : z(B("budget", e.budget), B("tenantId", e.tenantId), W("releasedAt")), n = yield* F.promise(() => e.store.query({
|
|
3041
3054
|
table: Z,
|
|
3042
3055
|
predicate: t,
|
|
3043
3056
|
order: []
|
|
3044
3057
|
})), r = 0;
|
|
3045
|
-
for (let t of n) (yield*
|
|
3058
|
+
for (let t of n) (yield* F.promise(() => e.store.updateMany("_voltro_budget_holds", {
|
|
3046
3059
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
3047
3060
|
outcome: e.outcome ?? "released"
|
|
3048
|
-
}, { where: z(B("id", String(t.id)), W("releasedAt")) }))) === 1 && (yield*
|
|
3061
|
+
}, { where: z(B("id", String(t.id)), W("releasedAt")) }))) === 1 && (yield* Br({
|
|
3049
3062
|
target: {
|
|
3050
3063
|
executionId: String(t.executionId),
|
|
3051
3064
|
workflowName: String(t.workflowName)
|
|
@@ -3055,9 +3068,9 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3055
3068
|
released: !0,
|
|
3056
3069
|
budget: e.budget
|
|
3057
3070
|
}
|
|
3058
|
-
}).pipe(
|
|
3071
|
+
}).pipe(F.catch(() => F.succeed({ completed: !1 }))), r += 1);
|
|
3059
3072
|
return { released: r };
|
|
3060
|
-
}),
|
|
3073
|
+
}), ei = async (e, t) => {
|
|
3061
3074
|
let n = t?.budget === void 0 ? W("releasedAt") : z(B("budget", t.budget), W("releasedAt"));
|
|
3062
3075
|
return (await e.query({
|
|
3063
3076
|
table: Z,
|
|
@@ -3073,8 +3086,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3073
3086
|
stepName: String(e.stepName),
|
|
3074
3087
|
heldAt: e.heldAt instanceof Date ? e.heldAt.toISOString() : String(e.heldAt ?? "")
|
|
3075
3088
|
}));
|
|
3076
|
-
},
|
|
3077
|
-
let t = await
|
|
3089
|
+
}, ti = async (e) => {
|
|
3090
|
+
let t = await ei(e), n = /* @__PURE__ */ new Map();
|
|
3078
3091
|
for (let e of t) {
|
|
3079
3092
|
let t = `${e.budget}\u0000${e.tenantId ?? ""}`;
|
|
3080
3093
|
n.has(t) || n.set(t, {
|
|
@@ -3083,84 +3096,84 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3083
3096
|
});
|
|
3084
3097
|
}
|
|
3085
3098
|
return [...n.values()];
|
|
3086
|
-
},
|
|
3099
|
+
}, ni = async (e, t) => {
|
|
3087
3100
|
if (e) try {
|
|
3088
3101
|
await e.recordEvent(t);
|
|
3089
3102
|
} catch {}
|
|
3090
|
-
},
|
|
3091
|
-
let
|
|
3103
|
+
}, ri = (t) => {
|
|
3104
|
+
let n = P.findErrorOption(t), r = t.reasons.filter(P.isDieReason).map((e) => e.defect), i = n._tag === "Some" ? n.value : r[0] ?? P.squash(t);
|
|
3092
3105
|
return {
|
|
3093
|
-
errorTag:
|
|
3094
|
-
errorMessage:
|
|
3106
|
+
errorTag: i && typeof i == "object" && "_tag" in i ? String(i._tag) : null,
|
|
3107
|
+
errorMessage: e(i)
|
|
3095
3108
|
};
|
|
3096
|
-
},
|
|
3097
|
-
let
|
|
3098
|
-
let
|
|
3099
|
-
if (
|
|
3100
|
-
let
|
|
3109
|
+
}, ii = (e, t) => {
|
|
3110
|
+
let n = F.gen(function* () {
|
|
3111
|
+
let n = t.pollIntervalMs ?? 200, r = t.maxPollIntervalMs ?? 5e3, i = t.timeoutMs ?? 3e4, a = yield* h, o = yield* F.serviceOption(y), c = o._tag === "Some" ? o.value : void 0;
|
|
3112
|
+
if (a === void 0) return yield* F.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
|
|
3113
|
+
let l = a, u = Date.now(), d = n;
|
|
3101
3114
|
for (;;) {
|
|
3102
|
-
let
|
|
3103
|
-
if (
|
|
3104
|
-
let
|
|
3115
|
+
let n = Date.now() - u;
|
|
3116
|
+
if (n > i) return yield* F.die(/* @__PURE__ */ Error(`awaitUpdate('${t.name}') timed out after ${n}ms`));
|
|
3117
|
+
let a = {
|
|
3105
3118
|
table: "_voltro_workflow_run_events",
|
|
3106
3119
|
order: [{
|
|
3107
3120
|
column: "occurredAt",
|
|
3108
3121
|
direction: "asc"
|
|
3109
3122
|
}],
|
|
3110
|
-
predicate: B("runId",
|
|
3123
|
+
predicate: B("runId", l),
|
|
3111
3124
|
projection: void 0,
|
|
3112
3125
|
skip: void 0,
|
|
3113
3126
|
take: 1e3
|
|
3114
|
-
}, o = yield*
|
|
3115
|
-
try: () => e.store.query(
|
|
3127
|
+
}, o = yield* F.tryPromise({
|
|
3128
|
+
try: () => e.store.query(a),
|
|
3116
3129
|
catch: (e) => e
|
|
3117
|
-
}),
|
|
3118
|
-
if (
|
|
3119
|
-
let e =
|
|
3120
|
-
yield*
|
|
3121
|
-
runId:
|
|
3130
|
+
}), f = Fe(o), p = o.find((e) => e.eventType === "update-requested" && e.payload?.updateName === t.name && typeof e.payload.updateId == "string" && !f.has(e.payload.updateId));
|
|
3131
|
+
if (p !== void 0) {
|
|
3132
|
+
let e = p.payload.updateId;
|
|
3133
|
+
yield* F.promise(() => ni(c, {
|
|
3134
|
+
runId: l,
|
|
3122
3135
|
eventType: "update-received",
|
|
3123
3136
|
payload: {
|
|
3124
3137
|
updateId: e,
|
|
3125
|
-
updateName:
|
|
3138
|
+
updateName: t.name
|
|
3126
3139
|
}
|
|
3127
3140
|
}));
|
|
3128
|
-
let
|
|
3129
|
-
runId:
|
|
3141
|
+
let n = yield* R.decodeUnknownEffect(t.schema)(s(p.payload)?.value).pipe(F.tapCause((n) => F.promise(() => ni(c, {
|
|
3142
|
+
runId: l,
|
|
3130
3143
|
eventType: "update-failed",
|
|
3131
3144
|
payload: {
|
|
3132
3145
|
updateId: e,
|
|
3133
|
-
updateName:
|
|
3134
|
-
...
|
|
3146
|
+
updateName: t.name,
|
|
3147
|
+
...ri(n)
|
|
3135
3148
|
}
|
|
3136
|
-
})))), r = yield* (
|
|
3137
|
-
runId:
|
|
3149
|
+
})))), r = yield* (t.handle ? t.handle(n) : F.succeed(n)).pipe(F.flatMap((e) => t.success ? R.decodeUnknownEffect(t.success)(e) : F.succeed(e))).pipe(F.tapCause((n) => F.promise(() => ni(c, {
|
|
3150
|
+
runId: l,
|
|
3138
3151
|
eventType: "update-failed",
|
|
3139
3152
|
payload: {
|
|
3140
3153
|
updateId: e,
|
|
3141
|
-
updateName:
|
|
3142
|
-
...
|
|
3154
|
+
updateName: t.name,
|
|
3155
|
+
...ri(n)
|
|
3143
3156
|
}
|
|
3144
3157
|
}))));
|
|
3145
|
-
return yield*
|
|
3146
|
-
runId:
|
|
3158
|
+
return yield* F.promise(() => ni(c, {
|
|
3159
|
+
runId: l,
|
|
3147
3160
|
eventType: "update-completed",
|
|
3148
3161
|
payload: {
|
|
3149
3162
|
updateId: e,
|
|
3150
|
-
updateName:
|
|
3163
|
+
updateName: t.name,
|
|
3151
3164
|
result: r
|
|
3152
3165
|
}
|
|
3153
3166
|
})), r;
|
|
3154
3167
|
}
|
|
3155
|
-
yield*
|
|
3168
|
+
yield* F.sleep(`${d} millis`), d = Math.min(d * 2, r);
|
|
3156
3169
|
}
|
|
3157
3170
|
});
|
|
3158
|
-
return
|
|
3159
|
-
name: `await-update:${
|
|
3160
|
-
success:
|
|
3161
|
-
execute:
|
|
3171
|
+
return i({
|
|
3172
|
+
name: `await-update:${t.name}`,
|
|
3173
|
+
success: t.success ?? t.schema,
|
|
3174
|
+
execute: n
|
|
3162
3175
|
});
|
|
3163
|
-
},
|
|
3176
|
+
}, ai = (e) => {
|
|
3164
3177
|
if (e == null) return null;
|
|
3165
3178
|
if (e instanceof Date) return e;
|
|
3166
3179
|
if (typeof e == "string" || typeof e == "number") {
|
|
@@ -3168,35 +3181,63 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3168
3181
|
return Number.isNaN(t.getTime()) ? null : t;
|
|
3169
3182
|
}
|
|
3170
3183
|
return null;
|
|
3171
|
-
},
|
|
3172
|
-
|
|
3173
|
-
|
|
3174
|
-
|
|
3175
|
-
|
|
3176
|
-
|
|
3177
|
-
|
|
3178
|
-
|
|
3179
|
-
|
|
3180
|
-
|
|
3181
|
-
|
|
3182
|
-
|
|
3184
|
+
}, oi = (e) => typeof e == "number" ? e : e == null ? null : Number(e), Q = (e) => e == null ? null : String(e), si = (e) => {
|
|
3185
|
+
if (vt.isProxy(e)) return !1;
|
|
3186
|
+
let t = Object.getPrototypeOf(e);
|
|
3187
|
+
if (t !== null && t !== Object.prototype) return !1;
|
|
3188
|
+
for (let t of Reflect.ownKeys(e)) {
|
|
3189
|
+
let n = Object.getOwnPropertyDescriptor(e, t);
|
|
3190
|
+
if (n === void 0 || !("value" in n)) return !1;
|
|
3191
|
+
}
|
|
3192
|
+
let n = Object.getOwnPropertyDescriptor(e, "stepName");
|
|
3193
|
+
if (n === void 0 || !("value" in n) || typeof n.value != "string") return !1;
|
|
3194
|
+
for (let t of [
|
|
3195
|
+
"attempt",
|
|
3196
|
+
"durationMs",
|
|
3197
|
+
"errorTag",
|
|
3198
|
+
"errorMessage",
|
|
3199
|
+
"startedAt"
|
|
3200
|
+
]) {
|
|
3201
|
+
let n = Object.getOwnPropertyDescriptor(e, t);
|
|
3202
|
+
if (n === void 0) {
|
|
3203
|
+
if (t in e) return !1;
|
|
3204
|
+
continue;
|
|
3205
|
+
}
|
|
3206
|
+
let r = n.value;
|
|
3207
|
+
if (typeof r == "object" && r && vt.isProxy(r) || !(t === "startedAt" && r instanceof Date && Object.getPrototypeOf(r) === Date.prototype && Reflect.ownKeys(r).length === 0) && r != null && typeof r != "number" && typeof r != "string" && typeof r != "boolean") return !1;
|
|
3208
|
+
}
|
|
3209
|
+
return !0;
|
|
3210
|
+
}, ci = (e) => {
|
|
3211
|
+
let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = !vt.isProxy(e) && Object.getPrototypeOf(e) === Array.prototype && !Object.hasOwn(e, Symbol.iterator) && e.find === Array.prototype.find, i = 0;
|
|
3212
|
+
for (let a of e) {
|
|
3213
|
+
let o = r ? Object.getOwnPropertyDescriptor(e, String(i)) : void 0;
|
|
3214
|
+
(o === void 0 || !("value" in o) || !si(a)) && (r = !1), i++;
|
|
3215
|
+
let s = String(a.stepName), c = t.get(s);
|
|
3216
|
+
c === void 0 ? (t.set(s, [a]), n.set(s, a)) : c.push(a);
|
|
3217
|
+
}
|
|
3218
|
+
let a = [];
|
|
3219
|
+
for (let [e, n] of t) {
|
|
3220
|
+
n.sort((e, t) => (oi(e.attempt) ?? 0) - (oi(t.attempt) ?? 0));
|
|
3221
|
+
let t = n[n.length - 1], r = Q(t.errorTag), i = Q(t.errorMessage), o = r !== null || i !== null ? {
|
|
3222
|
+
tag: r,
|
|
3223
|
+
message: i ?? ""
|
|
3183
3224
|
} : null;
|
|
3184
|
-
|
|
3225
|
+
a.push({
|
|
3185
3226
|
name: e,
|
|
3186
|
-
attempt:
|
|
3187
|
-
attempts:
|
|
3227
|
+
attempt: oi(t.attempt) ?? n.length,
|
|
3228
|
+
attempts: n.length,
|
|
3188
3229
|
status: t.status ?? "running",
|
|
3189
3230
|
input: t.input ?? null,
|
|
3190
3231
|
output: t.output ?? null,
|
|
3191
3232
|
error: o,
|
|
3192
|
-
durationMs:
|
|
3233
|
+
durationMs: oi(t.durationMs)
|
|
3193
3234
|
});
|
|
3194
3235
|
}
|
|
3195
|
-
return
|
|
3196
|
-
let
|
|
3197
|
-
return (
|
|
3198
|
-
}),
|
|
3199
|
-
},
|
|
3236
|
+
return a.sort((t, i) => {
|
|
3237
|
+
let a = r ? n.get(t.name) : e.find((e) => String(e.stepName) === t.name), o = r ? n.get(i.name) : e.find((e) => String(e.stepName) === i.name);
|
|
3238
|
+
return (ai(a?.startedAt)?.getTime() ?? 0) - (ai(o?.startedAt)?.getTime() ?? 0);
|
|
3239
|
+
}), a;
|
|
3240
|
+
}, li = (e) => {
|
|
3200
3241
|
if (e == null) return null;
|
|
3201
3242
|
if (typeof e == "string") try {
|
|
3202
3243
|
return JSON.parse(e);
|
|
@@ -3204,30 +3245,30 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3204
3245
|
return null;
|
|
3205
3246
|
}
|
|
3206
3247
|
return typeof e == "object" ? e : null;
|
|
3207
|
-
},
|
|
3208
|
-
let n =
|
|
3209
|
-
if (
|
|
3210
|
-
let
|
|
3248
|
+
}, ui = async (e, t) => {
|
|
3249
|
+
let n = dt(bt), i = (await t.query(n.where(ut(B("id", e), B("executionId", e))).limit(1).descriptor))[0];
|
|
3250
|
+
if (i === void 0) return null;
|
|
3251
|
+
let a = String(i.id), s = dt(xt), c = await t.query(s.where(B("runId", a)).descriptor);
|
|
3211
3252
|
return {
|
|
3212
|
-
id:
|
|
3213
|
-
executionId: Q(
|
|
3214
|
-
name: Q(
|
|
3215
|
-
status:
|
|
3216
|
-
input:
|
|
3217
|
-
output:
|
|
3218
|
-
subject:
|
|
3219
|
-
source: Q(
|
|
3220
|
-
steps:
|
|
3221
|
-
startedAt:
|
|
3222
|
-
finishedAt:
|
|
3223
|
-
traceId: Q(
|
|
3224
|
-
parentExecutionId: Q(
|
|
3225
|
-
parentClosePolicy: Q(
|
|
3253
|
+
id: a,
|
|
3254
|
+
executionId: Q(i.executionId) ?? "",
|
|
3255
|
+
name: Q(i.tag) ?? "",
|
|
3256
|
+
status: i.status ?? "running",
|
|
3257
|
+
input: r(i.payload ?? null, "workflow run payload"),
|
|
3258
|
+
output: o(i.output ?? null, "workflow run result"),
|
|
3259
|
+
subject: li(i.subject),
|
|
3260
|
+
source: Q(i.source),
|
|
3261
|
+
steps: ci(c),
|
|
3262
|
+
startedAt: ai(i.startedAt) ?? /* @__PURE__ */ new Date(0),
|
|
3263
|
+
finishedAt: ai(i.completedAt),
|
|
3264
|
+
traceId: Q(i.traceId),
|
|
3265
|
+
parentExecutionId: Q(i.parentExecutionId),
|
|
3266
|
+
parentClosePolicy: Q(i.parentClosePolicy)
|
|
3226
3267
|
};
|
|
3227
|
-
},
|
|
3268
|
+
}, di = () => {
|
|
3228
3269
|
let e = [], t = [], n = 0, r = 0;
|
|
3229
3270
|
return {
|
|
3230
|
-
layer:
|
|
3271
|
+
layer: et.succeed(y, {
|
|
3231
3272
|
startStep: async ({ runId: t, stepName: r, attempt: i, stepInput: a, retryPolicy: o }) => {
|
|
3232
3273
|
let s = `wfstep_mem_${++n}`;
|
|
3233
3274
|
return e.push({
|
|
@@ -3274,13 +3315,13 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3274
3315
|
readSteps: () => e,
|
|
3275
3316
|
readEvents: () => t
|
|
3276
3317
|
};
|
|
3277
|
-
},
|
|
3318
|
+
}, fi = (e, t, n) => F.gen(function* () {
|
|
3278
3319
|
let r = yield* Y;
|
|
3279
3320
|
for (;;) {
|
|
3280
|
-
if (yield*
|
|
3281
|
-
yield*
|
|
3321
|
+
if (yield* F.tryPromise(() => ie(t, e)).pipe(F.catch(() => F.sync(() => (n(), !1))))) return r.interrupted = !0, yield* F.interrupt;
|
|
3322
|
+
yield* F.sleep(1e3);
|
|
3282
3323
|
}
|
|
3283
|
-
}),
|
|
3324
|
+
}), pi = 8192, mi = 3, hi = 2e3, gi = () => {
|
|
3284
3325
|
let e = (e) => {
|
|
3285
3326
|
if (e === void 0) return;
|
|
3286
3327
|
let t = Number(e);
|
|
@@ -3290,7 +3331,7 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3290
3331
|
...t === void 0 ? {} : { maxRunReclaims: t },
|
|
3291
3332
|
...n === void 0 ? {} : { replayShapeLimit: n }
|
|
3292
3333
|
};
|
|
3293
|
-
},
|
|
3334
|
+
}, _i = (e) => {
|
|
3294
3335
|
let t = typeof e == "string" ? (() => {
|
|
3295
3336
|
try {
|
|
3296
3337
|
return JSON.parse(e);
|
|
@@ -3299,10 +3340,10 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3299
3340
|
}
|
|
3300
3341
|
})() : e;
|
|
3301
3342
|
if (Array.isArray(t)) return t.filter((e) => typeof e == "string");
|
|
3302
|
-
},
|
|
3343
|
+
}, vi = () => {
|
|
3303
3344
|
let e = globalThis.crypto;
|
|
3304
3345
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
3305
|
-
},
|
|
3346
|
+
}, yi = (e) => `${e}_${vi()}`, bi = (e, t = pi) => {
|
|
3306
3347
|
if (e == null) return e;
|
|
3307
3348
|
try {
|
|
3308
3349
|
let n = JSON.stringify(e);
|
|
@@ -3314,8 +3355,8 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3314
3355
|
} catch {
|
|
3315
3356
|
return { __unserialisable: String(e) };
|
|
3316
3357
|
}
|
|
3317
|
-
},
|
|
3318
|
-
if (n === null || !
|
|
3358
|
+
}, xi = async (e, t, n) => {
|
|
3359
|
+
if (n === null || !c() || !("value" in n || "result" in n || "errorMessage" in n) || e.query === void 0) return n;
|
|
3319
3360
|
let [r] = await e.query({
|
|
3320
3361
|
table: "_voltro_workflow_runs",
|
|
3321
3362
|
predicate: B("id", t),
|
|
@@ -3324,24 +3365,24 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3324
3365
|
skip: void 0,
|
|
3325
3366
|
projection: void 0
|
|
3326
3367
|
});
|
|
3327
|
-
return typeof r?.tag == "string" ?
|
|
3368
|
+
return typeof r?.tag == "string" ? p(r.tag, n) : n;
|
|
3328
3369
|
}, $ = (e) => {
|
|
3329
3370
|
let t = {};
|
|
3330
3371
|
for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
|
|
3331
|
-
return
|
|
3332
|
-
},
|
|
3333
|
-
let
|
|
3372
|
+
return f(t);
|
|
3373
|
+
}, Si = (n) => {
|
|
3374
|
+
let r = n.truncateBytes ?? pi, i = n.makeId ?? yi, a = (e, t) => n.log?.warn(e, t), o = (e, n) => n === !0 ? t(e, "workflow step value", u) : e, s = n.emit, c = n.recording === "coarse";
|
|
3334
3375
|
return {
|
|
3335
|
-
startStep: async ({ runId:
|
|
3336
|
-
if (!
|
|
3337
|
-
let
|
|
3338
|
-
id:
|
|
3339
|
-
runId:
|
|
3340
|
-
stepName:
|
|
3341
|
-
attempt:
|
|
3376
|
+
startStep: async ({ runId: t, stepName: l, attempt: u, stepInput: d, retryPolicy: f, sealed: p }) => {
|
|
3377
|
+
if (!c) try {
|
|
3378
|
+
let e = await n.store.insert("_voltro_workflow_run_steps", {
|
|
3379
|
+
id: i("ws"),
|
|
3380
|
+
runId: t,
|
|
3381
|
+
stepName: l,
|
|
3382
|
+
attempt: u,
|
|
3342
3383
|
status: "running",
|
|
3343
|
-
input:
|
|
3344
|
-
retryPolicy:
|
|
3384
|
+
input: d === void 0 ? null : o(bi(d, r), p),
|
|
3385
|
+
retryPolicy: f ?? null,
|
|
3345
3386
|
output: null,
|
|
3346
3387
|
errorTag: null,
|
|
3347
3388
|
errorMessage: null,
|
|
@@ -3349,240 +3390,240 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3349
3390
|
completedAt: null,
|
|
3350
3391
|
durationMs: null
|
|
3351
3392
|
});
|
|
3352
|
-
return
|
|
3393
|
+
return s?.("workflowSteps", {
|
|
3353
3394
|
op: "insert",
|
|
3354
|
-
row: $(
|
|
3355
|
-
}),
|
|
3356
|
-
} catch (
|
|
3357
|
-
|
|
3358
|
-
runId:
|
|
3359
|
-
stepName:
|
|
3360
|
-
attempt:
|
|
3361
|
-
reason: e
|
|
3395
|
+
row: $(e)
|
|
3396
|
+
}), e.id;
|
|
3397
|
+
} catch (n) {
|
|
3398
|
+
a("failed to record step start (continuing)", {
|
|
3399
|
+
runId: t,
|
|
3400
|
+
stepName: l,
|
|
3401
|
+
attempt: u,
|
|
3402
|
+
reason: e(n)
|
|
3362
3403
|
});
|
|
3363
3404
|
return;
|
|
3364
3405
|
}
|
|
3365
3406
|
},
|
|
3366
|
-
endStepSuccess: async ({ stepRecordId:
|
|
3367
|
-
if (!
|
|
3368
|
-
let
|
|
3407
|
+
endStepSuccess: async ({ stepRecordId: t, output: i, durationMs: l, sealed: u }) => {
|
|
3408
|
+
if (!c) try {
|
|
3409
|
+
let e = await n.store.update("_voltro_workflow_run_steps", t, {
|
|
3369
3410
|
status: "succeeded",
|
|
3370
|
-
output:
|
|
3411
|
+
output: o(bi(i, r), u),
|
|
3371
3412
|
completedAt: /* @__PURE__ */ new Date(),
|
|
3372
|
-
durationMs:
|
|
3413
|
+
durationMs: l
|
|
3373
3414
|
});
|
|
3374
|
-
|
|
3415
|
+
e && s?.("workflowSteps", {
|
|
3375
3416
|
op: "update",
|
|
3376
|
-
row: $(
|
|
3417
|
+
row: $(e)
|
|
3377
3418
|
});
|
|
3378
|
-
} catch (
|
|
3379
|
-
|
|
3380
|
-
stepRecordId:
|
|
3381
|
-
reason: e
|
|
3419
|
+
} catch (n) {
|
|
3420
|
+
a("failed to record step success", {
|
|
3421
|
+
stepRecordId: t,
|
|
3422
|
+
reason: e(n)
|
|
3382
3423
|
});
|
|
3383
3424
|
}
|
|
3384
3425
|
},
|
|
3385
|
-
endStepFailure: async ({ stepRecordId:
|
|
3386
|
-
if (!
|
|
3387
|
-
let
|
|
3426
|
+
endStepFailure: async ({ stepRecordId: t, errorTag: i, errorMessage: l, errorCause: u, durationMs: d, sealed: f }) => {
|
|
3427
|
+
if (!c) try {
|
|
3428
|
+
let e = await n.store.update("_voltro_workflow_run_steps", t, {
|
|
3388
3429
|
status: "failed",
|
|
3389
|
-
errorTag:
|
|
3390
|
-
errorMessage:
|
|
3391
|
-
errorCause:
|
|
3430
|
+
errorTag: i,
|
|
3431
|
+
errorMessage: l == null ? l : o(l, f),
|
|
3432
|
+
errorCause: u === void 0 ? null : o(bi(u, r), f),
|
|
3392
3433
|
completedAt: /* @__PURE__ */ new Date(),
|
|
3393
|
-
durationMs:
|
|
3434
|
+
durationMs: d
|
|
3394
3435
|
});
|
|
3395
|
-
|
|
3436
|
+
e && s?.("workflowSteps", {
|
|
3396
3437
|
op: "update",
|
|
3397
|
-
row: $(
|
|
3438
|
+
row: $(e)
|
|
3398
3439
|
});
|
|
3399
|
-
} catch (
|
|
3400
|
-
|
|
3401
|
-
stepRecordId:
|
|
3402
|
-
reason: e
|
|
3440
|
+
} catch (n) {
|
|
3441
|
+
a("failed to record step failure", {
|
|
3442
|
+
stepRecordId: t,
|
|
3443
|
+
reason: e(n)
|
|
3403
3444
|
});
|
|
3404
3445
|
}
|
|
3405
3446
|
},
|
|
3406
|
-
recordEvent: async ({ runId: t, eventType:
|
|
3407
|
-
let
|
|
3447
|
+
recordEvent: async ({ runId: t, eventType: r, payload: o, stepName: c, attempt: l }) => {
|
|
3448
|
+
let u = i("wfev"), d = !0;
|
|
3408
3449
|
try {
|
|
3409
|
-
let
|
|
3410
|
-
id:
|
|
3450
|
+
let e = await n.store.insert("_voltro_workflow_run_events", {
|
|
3451
|
+
id: u,
|
|
3411
3452
|
runId: t,
|
|
3412
|
-
eventType:
|
|
3413
|
-
payload: await
|
|
3453
|
+
eventType: r,
|
|
3454
|
+
payload: await xi(n.store, t, o ?? null),
|
|
3414
3455
|
occurredAt: /* @__PURE__ */ new Date(),
|
|
3415
|
-
stepName:
|
|
3416
|
-
attempt:
|
|
3456
|
+
stepName: c ?? null,
|
|
3457
|
+
attempt: l ?? null
|
|
3417
3458
|
});
|
|
3418
|
-
|
|
3459
|
+
s?.("workflowEvents", {
|
|
3419
3460
|
op: "insert",
|
|
3420
|
-
row: $(
|
|
3461
|
+
row: $(e)
|
|
3421
3462
|
});
|
|
3422
|
-
} catch (
|
|
3423
|
-
|
|
3463
|
+
} catch (n) {
|
|
3464
|
+
d = !1, a("failed to record workflow event (continuing)", {
|
|
3424
3465
|
runId: t,
|
|
3425
|
-
eventType:
|
|
3426
|
-
reason: e
|
|
3466
|
+
eventType: r,
|
|
3467
|
+
reason: e(n)
|
|
3427
3468
|
});
|
|
3428
3469
|
}
|
|
3429
|
-
if (
|
|
3430
|
-
let
|
|
3431
|
-
|
|
3470
|
+
if (n.wakeups !== void 0) {
|
|
3471
|
+
let e = o?.scheduledWakeAt, i = typeof e == "string" ? new Date(e) : void 0, a = o?.tenantId, s = typeof a == "string" ? a : void 0;
|
|
3472
|
+
r === "timer-set" && i !== void 0 && !Number.isNaN(i.getTime()) ? await n.wakeups.register(t, i, s).catch(() => {}) : (r === "timer-fired" || r === "run-succeeded" || r === "run-failed" || r === "run-cancelled") && await n.wakeups.cancel(t, s).catch(() => {});
|
|
3432
3473
|
}
|
|
3433
3474
|
return {
|
|
3434
|
-
id:
|
|
3435
|
-
recorded:
|
|
3475
|
+
id: u,
|
|
3476
|
+
recorded: d
|
|
3436
3477
|
};
|
|
3437
3478
|
}
|
|
3438
3479
|
};
|
|
3439
|
-
},
|
|
3440
|
-
let
|
|
3441
|
-
if (
|
|
3442
|
-
let
|
|
3480
|
+
}, Ci = (t, n, r) => F.gen(function* () {
|
|
3481
|
+
let i = t.store.query;
|
|
3482
|
+
if (i === void 0) return;
|
|
3483
|
+
let a = t.replayShapeLimit ?? 2e3, o = yield* F.promise(() => i.call(t.store, {
|
|
3443
3484
|
table: "_voltro_workflow_run_steps",
|
|
3444
3485
|
order: [{
|
|
3445
3486
|
column: "startedAt",
|
|
3446
3487
|
direction: "asc"
|
|
3447
3488
|
}],
|
|
3448
|
-
predicate: B("runId",
|
|
3489
|
+
predicate: B("runId", n),
|
|
3449
3490
|
projection: ["stepName"],
|
|
3450
3491
|
skip: void 0,
|
|
3451
|
-
take:
|
|
3452
|
-
}).catch((
|
|
3453
|
-
runId:
|
|
3454
|
-
reason: e
|
|
3492
|
+
take: a + 1
|
|
3493
|
+
}).catch((t) => (r("failed to read the replay shape (nondeterminism tripwire disabled for this attempt)", {
|
|
3494
|
+
runId: n,
|
|
3495
|
+
reason: e(t)
|
|
3455
3496
|
}), [])));
|
|
3456
|
-
if (
|
|
3457
|
-
if (
|
|
3458
|
-
|
|
3459
|
-
runId:
|
|
3460
|
-
limit:
|
|
3497
|
+
if (o.length === 0) return;
|
|
3498
|
+
if (o.length > a) {
|
|
3499
|
+
r("replay shape exceeds the step limit — nondeterminism tripwire disabled for this run", {
|
|
3500
|
+
runId: n,
|
|
3501
|
+
limit: a
|
|
3461
3502
|
});
|
|
3462
3503
|
return;
|
|
3463
3504
|
}
|
|
3464
|
-
let
|
|
3505
|
+
let s = o.flatMap((e) => {
|
|
3465
3506
|
let t = e.stepName;
|
|
3466
3507
|
return typeof t == "string" ? [{ stepName: t }] : [];
|
|
3467
3508
|
});
|
|
3468
|
-
return
|
|
3469
|
-
}),
|
|
3470
|
-
let
|
|
3471
|
-
yield*
|
|
3509
|
+
return s.length === 0 ? void 0 : b(s);
|
|
3510
|
+
}), wi = (t, n) => {
|
|
3511
|
+
let r = t.truncateBytes ?? pi, i = t.makeId ?? yi, a = t.recorder ?? Si(t), o = (e, n) => t.log?.warn(e, n), s = t.emit, c = (e) => F.gen(function* () {
|
|
3512
|
+
yield* F.sync(() => s?.("workflowEvents", {
|
|
3472
3513
|
op: "insert",
|
|
3473
3514
|
row: $(e)
|
|
3474
3515
|
}));
|
|
3475
|
-
let
|
|
3476
|
-
if (
|
|
3477
|
-
let e =
|
|
3478
|
-
yield*
|
|
3479
|
-
|
|
3516
|
+
let n = t.wakeups, r = e.runId;
|
|
3517
|
+
if (n !== void 0 && typeof r == "string") {
|
|
3518
|
+
let e = t.subject?.tenantId;
|
|
3519
|
+
yield* F.promise(() => n.cancel(r, typeof e == "string" ? e : void 0).catch(() => {
|
|
3520
|
+
o("failed to clear terminal workflow wakeup", { runId: r });
|
|
3480
3521
|
}));
|
|
3481
3522
|
}
|
|
3482
|
-
}),
|
|
3483
|
-
if (
|
|
3484
|
-
await
|
|
3485
|
-
workflowName:
|
|
3486
|
-
executionId:
|
|
3487
|
-
...
|
|
3488
|
-
status:
|
|
3523
|
+
}), u = (n, r, i) => F.promise(async () => {
|
|
3524
|
+
if (t.onParentClose) try {
|
|
3525
|
+
await t.onParentClose({
|
|
3526
|
+
workflowName: t.name,
|
|
3527
|
+
executionId: n,
|
|
3528
|
+
...i === void 0 ? {} : { runId: i },
|
|
3529
|
+
status: r
|
|
3489
3530
|
});
|
|
3490
|
-
} catch (
|
|
3491
|
-
|
|
3492
|
-
tag:
|
|
3493
|
-
executionId:
|
|
3494
|
-
status:
|
|
3495
|
-
reason:
|
|
3531
|
+
} catch (i) {
|
|
3532
|
+
o("failed to apply workflow parent-close policy", {
|
|
3533
|
+
tag: t.name,
|
|
3534
|
+
executionId: n,
|
|
3535
|
+
status: r,
|
|
3536
|
+
reason: e(i)
|
|
3496
3537
|
});
|
|
3497
3538
|
}
|
|
3498
|
-
}),
|
|
3499
|
-
if (
|
|
3500
|
-
await
|
|
3501
|
-
workflowName:
|
|
3502
|
-
executionId:
|
|
3503
|
-
...
|
|
3504
|
-
status:
|
|
3505
|
-
...
|
|
3539
|
+
}), f = (n, r, i, a) => F.promise(async () => {
|
|
3540
|
+
if (t.onTerminal) try {
|
|
3541
|
+
await t.onTerminal({
|
|
3542
|
+
workflowName: t.name,
|
|
3543
|
+
executionId: n,
|
|
3544
|
+
...i === void 0 ? {} : { runId: i },
|
|
3545
|
+
status: r,
|
|
3546
|
+
...a === void 0 ? {} : a
|
|
3506
3547
|
});
|
|
3507
|
-
} catch (
|
|
3508
|
-
|
|
3509
|
-
tag:
|
|
3510
|
-
executionId:
|
|
3511
|
-
status:
|
|
3512
|
-
reason:
|
|
3548
|
+
} catch (i) {
|
|
3549
|
+
o("workflow terminal observer failed", {
|
|
3550
|
+
tag: t.name,
|
|
3551
|
+
executionId: n,
|
|
3552
|
+
status: r,
|
|
3553
|
+
reason: e(i)
|
|
3513
3554
|
});
|
|
3514
3555
|
}
|
|
3515
3556
|
});
|
|
3516
|
-
return (
|
|
3517
|
-
let x = Date.now(),
|
|
3518
|
-
let
|
|
3519
|
-
|
|
3520
|
-
tag:
|
|
3557
|
+
return (p, b) => F.uninterruptibleMask((ne) => F.gen(function* () {
|
|
3558
|
+
let x = Date.now(), S = yield* _, re = yield* v, ie = t.parentExecutionId ?? S ?? null, C = t.parentGeneration ?? (t.parentExecutionId == null ? re : void 0) ?? null, ae = t.parentClosePolicy ?? null, w, T = (n, r) => r.pipe(F.catchCause((r) => P.hasInterrupts(r) ? F.failCause(r) : F.sync(() => {
|
|
3559
|
+
let i = P.squash(r);
|
|
3560
|
+
o(n, {
|
|
3561
|
+
tag: t.name,
|
|
3521
3562
|
executionId: b,
|
|
3522
|
-
reason:
|
|
3563
|
+
reason: e(i)
|
|
3523
3564
|
});
|
|
3524
|
-
}))),
|
|
3525
|
-
workflowName:
|
|
3565
|
+
}))), E = `wfrg_${vi()}`, oe = yield* F.serviceOption(Te), se = i("wr"), ce = yield* F.sync(() => t.encodePayload === void 0 ? p : t.encodePayload(p)), D = yield* F.promise(() => t.transaction((e) => Ut(e, {
|
|
3566
|
+
workflowName: t.name,
|
|
3526
3567
|
executionId: b,
|
|
3527
|
-
generation:
|
|
3568
|
+
generation: E,
|
|
3528
3569
|
now: x,
|
|
3529
3570
|
delivery: oe._tag === "Some" ? oe.value : null,
|
|
3530
3571
|
initialRow: {
|
|
3531
3572
|
id: se,
|
|
3532
3573
|
payload: ce,
|
|
3533
|
-
workflowVersion:
|
|
3534
|
-
workflowPatches:
|
|
3574
|
+
workflowVersion: t.workflowVersion ?? null,
|
|
3575
|
+
workflowPatches: t.workflowPatches ?? null,
|
|
3535
3576
|
output: null,
|
|
3536
|
-
subject:
|
|
3537
|
-
source:
|
|
3577
|
+
subject: t.subject ?? null,
|
|
3578
|
+
source: t.source ?? null,
|
|
3538
3579
|
errorTag: null,
|
|
3539
3580
|
errorMessage: null,
|
|
3540
3581
|
cancelled: !1,
|
|
3541
3582
|
startedAt: new Date(x),
|
|
3542
3583
|
completedAt: null,
|
|
3543
3584
|
durationMs: null,
|
|
3544
|
-
traceId:
|
|
3545
|
-
parentExecutionId:
|
|
3546
|
-
parentGeneration:
|
|
3585
|
+
traceId: t.traceId ?? null,
|
|
3586
|
+
parentExecutionId: ie,
|
|
3587
|
+
parentGeneration: C,
|
|
3547
3588
|
parentClosePolicy: ae
|
|
3548
3589
|
}
|
|
3549
3590
|
})));
|
|
3550
|
-
if (typeof
|
|
3551
|
-
if (
|
|
3552
|
-
let e =
|
|
3553
|
-
yield*
|
|
3554
|
-
|
|
3591
|
+
if (typeof D.row.id != "string") return yield* F.die(/* @__PURE__ */ Error("Recorded workflow entry has no run identity"));
|
|
3592
|
+
if (w = D.row.id, D.restartEvent !== void 0) {
|
|
3593
|
+
let e = D.restartEvent;
|
|
3594
|
+
yield* T("failed to observe recorded workflow restart", F.sync(() => {
|
|
3595
|
+
s?.("workflowEvents", {
|
|
3555
3596
|
op: "insert",
|
|
3556
3597
|
row: $(e)
|
|
3557
3598
|
});
|
|
3558
3599
|
}));
|
|
3559
3600
|
}
|
|
3560
|
-
if (
|
|
3601
|
+
if (D.kind === "cancelled" || D.kind === "already-cancelled") {
|
|
3561
3602
|
let e = yield* Y;
|
|
3562
|
-
return e.interrupted = !0,
|
|
3563
|
-
if (
|
|
3603
|
+
return e.interrupted = !0, D.kind === "cancelled" && (yield* T("failed to observe suspended workflow cancellation", F.gen(function* () {
|
|
3604
|
+
if (s?.("workflowRuns", {
|
|
3564
3605
|
op: "update",
|
|
3565
|
-
row: $(
|
|
3566
|
-
}),
|
|
3567
|
-
yield*
|
|
3568
|
-
})), yield*
|
|
3569
|
-
name:
|
|
3606
|
+
row: $(D.row)
|
|
3607
|
+
}), D.terminalEvent === void 0) return yield* F.die(/* @__PURE__ */ Error("Cancelled entry has no terminal event"));
|
|
3608
|
+
yield* c(D.terminalEvent), yield* u(b, "cancelled", w);
|
|
3609
|
+
})), yield* f(b, "cancelled", w), yield* F.sync(() => t.recordRun?.({
|
|
3610
|
+
name: t.name,
|
|
3570
3611
|
status: "cancelled",
|
|
3571
3612
|
durationMs: 0
|
|
3572
|
-
}))), yield*
|
|
3613
|
+
}))), yield* F.interrupt;
|
|
3573
3614
|
}
|
|
3574
|
-
let
|
|
3575
|
-
if (
|
|
3576
|
-
let e = `Workflow '${
|
|
3615
|
+
let O = D.previous, le = O?.workflowVersion ?? null;
|
|
3616
|
+
if (O?.id !== void 0 && le !== null && t.workflowCompatibleVersions !== void 0 && t.workflowCompatibleVersions !== null && !t.workflowCompatibleVersions.includes(le)) {
|
|
3617
|
+
let e = `Workflow '${t.name}' run '${b}' was started on version ${le}, but current code is compatible with ${t.workflowCompatibleVersions.join(", ")}`, n = t.failureContext ?? {
|
|
3577
3618
|
handler: null,
|
|
3578
3619
|
callerContext: null,
|
|
3579
3620
|
tenantId: null
|
|
3580
|
-
},
|
|
3621
|
+
}, r = yield* F.promise(() => t.transaction((r) => Jt(r, {
|
|
3581
3622
|
owner: {
|
|
3582
|
-
runId:
|
|
3583
|
-
workflowName:
|
|
3623
|
+
runId: w,
|
|
3624
|
+
workflowName: t.name,
|
|
3584
3625
|
executionId: b,
|
|
3585
|
-
generation:
|
|
3626
|
+
generation: E
|
|
3586
3627
|
},
|
|
3587
3628
|
now: Date.now(),
|
|
3588
3629
|
durationMs: 0,
|
|
@@ -3590,278 +3631,295 @@ var gt = qe.layerMemory, _t = K("_voltro_workflow_runs", {
|
|
|
3590
3631
|
status: "failed",
|
|
3591
3632
|
errorTag: "WorkflowVersionIncompatible",
|
|
3592
3633
|
errorMessage: e,
|
|
3593
|
-
...
|
|
3634
|
+
...n
|
|
3594
3635
|
}
|
|
3595
3636
|
})));
|
|
3596
|
-
return
|
|
3597
|
-
|
|
3637
|
+
return r.kind === "committed" && (yield* T("failed to observe workflow version rejection", F.gen(function* () {
|
|
3638
|
+
s?.("workflowRuns", {
|
|
3598
3639
|
op: "update",
|
|
3599
|
-
row: $(
|
|
3600
|
-
}), yield*
|
|
3601
|
-
})), yield*
|
|
3602
|
-
payload:
|
|
3640
|
+
row: $(r.row)
|
|
3641
|
+
}), yield* c(r.terminalEvent), yield* u(b, "failed", w);
|
|
3642
|
+
})), yield* f(b, "failed", w, {
|
|
3643
|
+
payload: D.row.payload,
|
|
3603
3644
|
errorTag: "WorkflowVersionIncompatible",
|
|
3604
3645
|
errorMessage: e
|
|
3605
|
-
}), yield*
|
|
3606
|
-
name:
|
|
3646
|
+
}), yield* F.sync(() => t.recordRun?.({
|
|
3647
|
+
name: t.name,
|
|
3607
3648
|
status: "failed",
|
|
3608
3649
|
durationMs: 0
|
|
3609
|
-
})),
|
|
3610
|
-
workflow:
|
|
3650
|
+
})), o("workflow run failed", {
|
|
3651
|
+
workflow: t.name,
|
|
3611
3652
|
executionId: b,
|
|
3612
|
-
runId:
|
|
3653
|
+
runId: w,
|
|
3613
3654
|
errorTag: "WorkflowVersionIncompatible",
|
|
3614
3655
|
cause: e
|
|
3615
|
-
})), yield*
|
|
3616
|
-
}
|
|
3617
|
-
let ue =
|
|
3618
|
-
if (
|
|
3619
|
-
|
|
3620
|
-
let e =
|
|
3621
|
-
if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0) return yield*
|
|
3622
|
-
let
|
|
3623
|
-
if (
|
|
3624
|
-
let
|
|
3625
|
-
runId:
|
|
3626
|
-
workflowName:
|
|
3656
|
+
})), yield* F.fail(Error(e));
|
|
3657
|
+
}
|
|
3658
|
+
let ue = t.workflowPatches ?? [], de;
|
|
3659
|
+
if (O?.id !== void 0) {
|
|
3660
|
+
w = O.id, ue = _i(O.workflowPatches) ?? ue;
|
|
3661
|
+
let e = D.row.reclaimCount;
|
|
3662
|
+
if (typeof e != "number" || !Number.isSafeInteger(e) || e < 0) return yield* F.die(/* @__PURE__ */ Error("Recorded workflow entry has an invalid reclaim counter"));
|
|
3663
|
+
let n = e > 0, r = t.maxRunReclaims ?? 3;
|
|
3664
|
+
if (n && e >= r) {
|
|
3665
|
+
let n = `Workflow '${t.name}' run '${b}' killed its runner ${e} times in a row; parked instead of reclaimed again (maxRunReclaims=${r}).`, i = yield* F.promise(() => t.transaction((e) => Kt(e, {
|
|
3666
|
+
runId: w,
|
|
3667
|
+
workflowName: t.name,
|
|
3627
3668
|
executionId: b,
|
|
3628
|
-
generation:
|
|
3669
|
+
generation: E
|
|
3629
3670
|
}, {
|
|
3630
3671
|
errorTag: "WorkflowCrashLooped",
|
|
3631
|
-
errorMessage:
|
|
3672
|
+
errorMessage: n
|
|
3632
3673
|
})));
|
|
3633
|
-
|
|
3634
|
-
|
|
3674
|
+
i.kind === "committed" && (yield* T("failed to observe workflow crash-loop park", F.gen(function* () {
|
|
3675
|
+
s?.("workflowRuns", {
|
|
3635
3676
|
op: "update",
|
|
3636
|
-
row: $(
|
|
3637
|
-
}), yield*
|
|
3638
|
-
runId:
|
|
3677
|
+
row: $(i.row)
|
|
3678
|
+
}), yield* F.promise(() => a.recordEvent({
|
|
3679
|
+
runId: w,
|
|
3639
3680
|
eventType: "run-crashlooped",
|
|
3640
3681
|
payload: {
|
|
3641
3682
|
reclaimCount: e,
|
|
3642
|
-
maxRunReclaims:
|
|
3683
|
+
maxRunReclaims: r,
|
|
3643
3684
|
executionId: b,
|
|
3644
|
-
tag:
|
|
3685
|
+
tag: t.name
|
|
3645
3686
|
}
|
|
3646
3687
|
}));
|
|
3647
|
-
})),
|
|
3648
|
-
tag:
|
|
3688
|
+
})), o("workflow run parked after repeated runner deaths", {
|
|
3689
|
+
tag: t.name,
|
|
3649
3690
|
executionId: b,
|
|
3650
|
-
runId:
|
|
3691
|
+
runId: w,
|
|
3651
3692
|
reclaimCount: e,
|
|
3652
|
-
maxRunReclaims:
|
|
3693
|
+
maxRunReclaims: r
|
|
3653
3694
|
}));
|
|
3654
|
-
let
|
|
3655
|
-
return yield*
|
|
3695
|
+
let c = yield* Y;
|
|
3696
|
+
return yield* Ye.suspend(c);
|
|
3656
3697
|
}
|
|
3657
|
-
|
|
3658
|
-
|
|
3698
|
+
de = yield* Ci(t, w, o), yield* T("failed to record workflow re-entry", F.gen(function* () {
|
|
3699
|
+
s?.("workflowRuns", {
|
|
3659
3700
|
op: "update",
|
|
3660
|
-
row: $(
|
|
3661
|
-
}),
|
|
3662
|
-
runId:
|
|
3701
|
+
row: $(D.row)
|
|
3702
|
+
}), n && (yield* F.promise(() => a.recordEvent({
|
|
3703
|
+
runId: w,
|
|
3663
3704
|
eventType: "run-resumed",
|
|
3664
3705
|
payload: {
|
|
3665
3706
|
reason: "runner-reclaim",
|
|
3666
3707
|
reclaimCount: e,
|
|
3667
|
-
maxRunReclaims:
|
|
3708
|
+
maxRunReclaims: r
|
|
3668
3709
|
}
|
|
3669
3710
|
})));
|
|
3670
3711
|
}));
|
|
3671
|
-
} else yield*
|
|
3672
|
-
if (
|
|
3712
|
+
} else yield* T("failed to emit recorded workflow start", F.gen(function* () {
|
|
3713
|
+
if (s?.("workflowRuns", {
|
|
3673
3714
|
op: "insert",
|
|
3674
|
-
row: $(
|
|
3675
|
-
}),
|
|
3676
|
-
let e =
|
|
3677
|
-
yield*
|
|
3715
|
+
row: $(D.row)
|
|
3716
|
+
}), w) {
|
|
3717
|
+
let e = w;
|
|
3718
|
+
yield* F.promise(() => a.recordEvent({
|
|
3678
3719
|
runId: e,
|
|
3679
3720
|
eventType: "run-started",
|
|
3680
3721
|
payload: {
|
|
3681
|
-
tag:
|
|
3722
|
+
tag: t.name,
|
|
3682
3723
|
executionId: b,
|
|
3683
|
-
source:
|
|
3684
|
-
workflowVersion:
|
|
3685
|
-
workflowPatches:
|
|
3686
|
-
parentExecutionId:
|
|
3724
|
+
source: t.source ?? null,
|
|
3725
|
+
workflowVersion: t.workflowVersion ?? null,
|
|
3726
|
+
workflowPatches: t.workflowPatches ?? null,
|
|
3727
|
+
parentExecutionId: ie,
|
|
3687
3728
|
parentClosePolicy: ae
|
|
3688
3729
|
}
|
|
3689
3730
|
}));
|
|
3690
3731
|
}
|
|
3691
3732
|
}));
|
|
3692
|
-
let
|
|
3693
|
-
|
|
3694
|
-
|
|
3695
|
-
|
|
3696
|
-
|
|
3697
|
-
|
|
3698
|
-
|
|
3699
|
-
|
|
3700
|
-
|
|
3701
|
-
|
|
3702
|
-
|
|
3733
|
+
let fe = t.subject?.tenantId, pe = F.suspend(() => n(p, b, E)).pipe(F.provideService(h, w), F.provideService(_, b), F.provideService(v, E), F.provideService(g, typeof fe == "string" ? fe : void 0), F.provideService(ee, ue), F.provideService(te, de), F.provideService(y, a)), me = t.pluginWorkflowStepLayer ? pe.pipe(F.provide(t.pluginWorkflowStepLayer)) : pe, k = yield* Ye.intoResult(F.gen(function* () {
|
|
3734
|
+
let e = yield* F.forkChild(ne(me)), n = yield* F.forkChild(ne(fi({
|
|
3735
|
+
runId: w,
|
|
3736
|
+
workflowName: t.name,
|
|
3737
|
+
executionId: b,
|
|
3738
|
+
generation: E
|
|
3739
|
+
}, async (e) => t.store.query(e), () => o("workflow control read failed; retrying without claiming cancellation", {
|
|
3740
|
+
executionId: b,
|
|
3741
|
+
runId: w
|
|
3742
|
+
})))), r = yield* F.exit(ne(F.raceAll([F.map(I.await(e), (e) => ({
|
|
3743
|
+
other: n,
|
|
3744
|
+
exit: e
|
|
3745
|
+
})), F.map(I.await(n), (t) => ({
|
|
3746
|
+
other: e,
|
|
3747
|
+
exit: t
|
|
3748
|
+
}))])));
|
|
3749
|
+
if ($e.isSuccess(r)) {
|
|
3750
|
+
yield* I.interrupt(r.value.other);
|
|
3751
|
+
let e = r.value.exit;
|
|
3752
|
+
if ($e.isFailure(e) && P.hasInterruptsOnly(e.cause)) {
|
|
3753
|
+
let e = yield* Y;
|
|
3754
|
+
e.suspended || (e.interrupted = !0);
|
|
3755
|
+
}
|
|
3756
|
+
return yield* e;
|
|
3757
|
+
}
|
|
3758
|
+
yield* I.interrupt(n), yield* I.interrupt(e);
|
|
3759
|
+
let i = yield* Y;
|
|
3760
|
+
return i.interrupted = !0, yield* I.await(e);
|
|
3703
3761
|
}));
|
|
3704
|
-
if (
|
|
3705
|
-
let
|
|
3706
|
-
runId:
|
|
3707
|
-
workflowName:
|
|
3762
|
+
if (Ye.isResult(k) && k._tag === "Suspended") {
|
|
3763
|
+
let n = k.cause, r = n !== void 0 && n.reasons.length > 0, i = r ? P.squash(n) : void 0, o = i && typeof i == "object" && "_tag" in i ? String(i._tag) : null, c = r ? e(i) : null, u = yield* F.promise(() => t.transaction((e) => Kt(e, {
|
|
3764
|
+
runId: w,
|
|
3765
|
+
workflowName: t.name,
|
|
3708
3766
|
executionId: b,
|
|
3709
|
-
generation:
|
|
3767
|
+
generation: E
|
|
3710
3768
|
}, {
|
|
3711
|
-
errorTag:
|
|
3712
|
-
errorMessage:
|
|
3769
|
+
errorTag: o,
|
|
3770
|
+
errorMessage: c
|
|
3713
3771
|
})));
|
|
3714
|
-
|
|
3715
|
-
error:
|
|
3772
|
+
u.kind === "committed" && r && (yield* F.sync(() => nt({
|
|
3773
|
+
error: i,
|
|
3716
3774
|
source: "workflow",
|
|
3717
|
-
name:
|
|
3718
|
-
contentSensitive:
|
|
3719
|
-
...
|
|
3775
|
+
name: t.name,
|
|
3776
|
+
contentSensitive: l(t.name),
|
|
3777
|
+
...t.traceId ? { traceId: t.traceId } : {},
|
|
3720
3778
|
fields: {
|
|
3721
3779
|
executionId: b,
|
|
3722
3780
|
suspendedOnFailure: !0,
|
|
3723
|
-
...
|
|
3724
|
-
...
|
|
3781
|
+
...o ? { errorTag: o } : {},
|
|
3782
|
+
...w ? { runId: w } : {}
|
|
3725
3783
|
}
|
|
3726
|
-
}))),
|
|
3727
|
-
|
|
3784
|
+
}))), u.kind === "committed" && (yield* T("failed to observe workflow suspend", F.gen(function* () {
|
|
3785
|
+
s?.("workflowRuns", {
|
|
3728
3786
|
op: "update",
|
|
3729
|
-
row: $(
|
|
3730
|
-
}), yield*
|
|
3731
|
-
runId:
|
|
3787
|
+
row: $(u.row)
|
|
3788
|
+
}), yield* F.promise(() => a.recordEvent({
|
|
3789
|
+
runId: w,
|
|
3732
3790
|
eventType: "run-suspended",
|
|
3733
|
-
payload:
|
|
3791
|
+
payload: r ? {
|
|
3734
3792
|
reason: "suspend-on-failure",
|
|
3735
|
-
errorTag:
|
|
3736
|
-
errorMessage:
|
|
3793
|
+
errorTag: o,
|
|
3794
|
+
errorMessage: c
|
|
3737
3795
|
} : { reason: "workflow-suspend" }
|
|
3738
3796
|
}));
|
|
3739
3797
|
})));
|
|
3740
|
-
let
|
|
3741
|
-
return yield*
|
|
3742
|
-
}
|
|
3743
|
-
let
|
|
3744
|
-
if (
|
|
3745
|
-
let
|
|
3746
|
-
if (
|
|
3747
|
-
let n =
|
|
3748
|
-
|
|
3749
|
-
tag:
|
|
3798
|
+
let d = yield* Y;
|
|
3799
|
+
return yield* Ye.suspend(d);
|
|
3800
|
+
}
|
|
3801
|
+
let A = k;
|
|
3802
|
+
if (de !== void 0 && w !== void 0) {
|
|
3803
|
+
let e = de.settle();
|
|
3804
|
+
if (e.length > 0) {
|
|
3805
|
+
let n = w;
|
|
3806
|
+
o("workflow replay reached a different step shape than this run recorded", {
|
|
3807
|
+
tag: t.name,
|
|
3750
3808
|
executionId: b,
|
|
3751
3809
|
runId: n,
|
|
3752
|
-
findings:
|
|
3753
|
-
}), yield*
|
|
3754
|
-
for (let
|
|
3810
|
+
findings: e.map((e) => `${e.kind}:${e.stepName}`)
|
|
3811
|
+
}), yield* T("failed to record nondeterminism findings", F.promise(async () => {
|
|
3812
|
+
for (let t of e) await a.recordEvent({
|
|
3755
3813
|
runId: n,
|
|
3756
3814
|
eventType: "nondeterminism-suspected",
|
|
3757
|
-
payload:
|
|
3815
|
+
payload: m(t)
|
|
3758
3816
|
}).catch(() => void 0);
|
|
3759
3817
|
}));
|
|
3760
3818
|
}
|
|
3761
3819
|
}
|
|
3762
|
-
if (
|
|
3763
|
-
let
|
|
3764
|
-
if ((yield* Y).interrupted &&
|
|
3765
|
-
let
|
|
3820
|
+
if ($e.isFailure(A.exit)) {
|
|
3821
|
+
let n = A.exit.cause;
|
|
3822
|
+
if ((yield* Y).interrupted && P.hasInterruptsOnly(n)) {
|
|
3823
|
+
let e = Date.now(), r = yield* F.promise(() => t.transaction((n) => Jt(n, {
|
|
3766
3824
|
owner: {
|
|
3767
|
-
runId:
|
|
3768
|
-
workflowName:
|
|
3825
|
+
runId: w,
|
|
3826
|
+
workflowName: t.name,
|
|
3769
3827
|
executionId: b,
|
|
3770
|
-
generation:
|
|
3828
|
+
generation: E
|
|
3771
3829
|
},
|
|
3772
|
-
now:
|
|
3773
|
-
durationMs:
|
|
3830
|
+
now: e,
|
|
3831
|
+
durationMs: e - x,
|
|
3774
3832
|
outcome: { status: "cancelled" }
|
|
3775
3833
|
})));
|
|
3776
|
-
return
|
|
3777
|
-
|
|
3834
|
+
return r.kind === "committed" && (yield* T("failed to observe workflow cancellation", F.gen(function* () {
|
|
3835
|
+
s?.("workflowRuns", {
|
|
3778
3836
|
op: "update",
|
|
3779
|
-
row: $(
|
|
3780
|
-
}), yield*
|
|
3781
|
-
})), yield*
|
|
3782
|
-
name:
|
|
3837
|
+
row: $(r.row)
|
|
3838
|
+
}), yield* c(r.terminalEvent), yield* u(b, "cancelled", w);
|
|
3839
|
+
})), yield* f(b, "cancelled", w), yield* F.sync(() => t.recordRun?.({
|
|
3840
|
+
name: t.name,
|
|
3783
3841
|
status: "cancelled",
|
|
3784
|
-
durationMs:
|
|
3785
|
-
}))), yield*
|
|
3842
|
+
durationMs: e - x
|
|
3843
|
+
}))), yield* F.failCause(n);
|
|
3786
3844
|
}
|
|
3787
|
-
let
|
|
3845
|
+
let r = P.findErrorOption(n), i = r._tag === "Some" ? r.value : P.squash(n), a = i && typeof i == "object" && "_tag" in i ? String(i._tag) : null, m = e(i), h = Date.now(), g = t.failureContext ?? {
|
|
3788
3846
|
handler: null,
|
|
3789
3847
|
callerContext: null,
|
|
3790
3848
|
tenantId: null
|
|
3791
|
-
},
|
|
3849
|
+
}, _ = yield* F.promise(() => t.transaction((e) => Jt(e, {
|
|
3792
3850
|
owner: {
|
|
3793
|
-
runId:
|
|
3794
|
-
workflowName:
|
|
3851
|
+
runId: w,
|
|
3852
|
+
workflowName: t.name,
|
|
3795
3853
|
executionId: b,
|
|
3796
|
-
generation:
|
|
3854
|
+
generation: E
|
|
3797
3855
|
},
|
|
3798
|
-
now:
|
|
3799
|
-
durationMs:
|
|
3856
|
+
now: h,
|
|
3857
|
+
durationMs: h - x,
|
|
3800
3858
|
outcome: {
|
|
3801
3859
|
status: "failed",
|
|
3802
|
-
errorTag:
|
|
3803
|
-
errorMessage:
|
|
3804
|
-
...
|
|
3860
|
+
errorTag: a,
|
|
3861
|
+
errorMessage: m,
|
|
3862
|
+
...g
|
|
3805
3863
|
}
|
|
3806
3864
|
})));
|
|
3807
|
-
return
|
|
3808
|
-
workflow:
|
|
3865
|
+
return _.kind === "committed" ? (o("workflow run failed", {
|
|
3866
|
+
workflow: t.name,
|
|
3809
3867
|
executionId: b,
|
|
3810
|
-
runId:
|
|
3811
|
-
...
|
|
3812
|
-
cause:
|
|
3813
|
-
}), yield*
|
|
3814
|
-
error:
|
|
3868
|
+
runId: w,
|
|
3869
|
+
...a ? { errorTag: a } : {},
|
|
3870
|
+
cause: d(t.name, i)
|
|
3871
|
+
}), yield* F.sync(() => nt({
|
|
3872
|
+
error: i,
|
|
3815
3873
|
source: "workflow",
|
|
3816
|
-
name:
|
|
3817
|
-
contentSensitive:
|
|
3818
|
-
...
|
|
3874
|
+
name: t.name,
|
|
3875
|
+
contentSensitive: l(t.name),
|
|
3876
|
+
...t.traceId ? { traceId: t.traceId } : {},
|
|
3819
3877
|
fields: {
|
|
3820
3878
|
executionId: b,
|
|
3821
|
-
...
|
|
3822
|
-
...
|
|
3879
|
+
...a ? { errorTag: a } : {},
|
|
3880
|
+
...w ? { runId: w } : {}
|
|
3823
3881
|
}
|
|
3824
|
-
})),
|
|
3825
|
-
|
|
3882
|
+
})), w && (yield* T("failed to record workflow failure", F.gen(function* () {
|
|
3883
|
+
s?.("workflowRuns", {
|
|
3826
3884
|
op: "update",
|
|
3827
|
-
row: $(
|
|
3828
|
-
}), yield*
|
|
3829
|
-
}))), yield*
|
|
3830
|
-
payload:
|
|
3831
|
-
errorTag:
|
|
3832
|
-
errorMessage:
|
|
3833
|
-
}), yield*
|
|
3834
|
-
name:
|
|
3885
|
+
row: $(_.row)
|
|
3886
|
+
}), yield* c(_.terminalEvent), yield* u(b, "failed", w);
|
|
3887
|
+
}))), yield* f(b, "failed", w, {
|
|
3888
|
+
payload: p,
|
|
3889
|
+
errorTag: a,
|
|
3890
|
+
errorMessage: m
|
|
3891
|
+
}), yield* F.sync(() => t.recordRun?.({
|
|
3892
|
+
name: t.name,
|
|
3835
3893
|
status: "failed",
|
|
3836
3894
|
durationMs: Date.now() - x
|
|
3837
|
-
})), yield*
|
|
3895
|
+
})), yield* F.failCause(n)) : yield* F.failCause(n);
|
|
3838
3896
|
}
|
|
3839
|
-
let
|
|
3897
|
+
let he = A.exit.value, ge = Date.now(), _e = yield* F.promise(() => t.transaction((e) => Jt(e, {
|
|
3840
3898
|
owner: {
|
|
3841
|
-
runId:
|
|
3842
|
-
workflowName:
|
|
3899
|
+
runId: w,
|
|
3900
|
+
workflowName: t.name,
|
|
3843
3901
|
executionId: b,
|
|
3844
|
-
generation:
|
|
3902
|
+
generation: E
|
|
3845
3903
|
},
|
|
3846
|
-
now:
|
|
3847
|
-
durationMs:
|
|
3904
|
+
now: ge,
|
|
3905
|
+
durationMs: ge - x,
|
|
3848
3906
|
outcome: {
|
|
3849
3907
|
status: "succeeded",
|
|
3850
|
-
output:
|
|
3908
|
+
output: bi(he, r)
|
|
3851
3909
|
}
|
|
3852
3910
|
})));
|
|
3853
|
-
return
|
|
3854
|
-
|
|
3911
|
+
return _e.kind === "committed" ? (w && (yield* T("failed to record workflow success", F.gen(function* () {
|
|
3912
|
+
s?.("workflowRuns", {
|
|
3855
3913
|
op: "update",
|
|
3856
|
-
row: $(
|
|
3857
|
-
}), yield*
|
|
3858
|
-
}))), yield*
|
|
3859
|
-
name:
|
|
3914
|
+
row: $(_e.row)
|
|
3915
|
+
}), yield* c(_e.terminalEvent), yield* u(b, "succeeded", w);
|
|
3916
|
+
}))), yield* f(b, "succeeded", w), yield* F.sync(() => t.recordRun?.({
|
|
3917
|
+
name: t.name,
|
|
3860
3918
|
status: "succeeded",
|
|
3861
3919
|
durationMs: Date.now() - x,
|
|
3862
3920
|
completedAtSec: Date.now() / 1e3
|
|
3863
|
-
})),
|
|
3864
|
-
});
|
|
3921
|
+
})), he) : he;
|
|
3922
|
+
}));
|
|
3865
3923
|
};
|
|
3866
3924
|
//#endregion
|
|
3867
|
-
export {
|
|
3925
|
+
export { Mn as $, Tr as A, ur as B, zr as C, Ot as Ct, Ar as D, bt as Dt, kr as E, xt as Et, yr as F, Pn as G, tr as H, vr as I, wn as J, Hn as K, gr as L, Cr as M, xr as N, Mr as O, yt as Ot, pr as P, On as Q, hr as R, Yr as S, kt as St, Ir as T, St as Tt, Nn as U, nr as V, Fn as W, Sn as X, Tn as Y, xn as Z, Ur as _, Et as _t, gi as a, gn as at, ei as b, Mt as bt, wi as c, ln as ct, ii as d, Gt as dt, kn as et, Z as f, Jt as ft, Wr as g, jt as gt, Gr as h, wt as ht, _i as i, mn as it, Er as j, Nr as k, di as l, un as lt, Jr as m, Rt as mt, hi as n, yn as nt, $ as o, dn as ot, qr as p, Ut as pt, Cn as q, Si as r, _n as rt, bi as s, fn as st, mi as t, bn as tt, ui as u, Yt as ut, Hr as v, Dt as vt, Br as w, Ct as wt, $r as x, At as xt, ti as y, Tt as yt, $n as z };
|