@voltro/workflow 0.62.1 → 0.62.2
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 +21 -0
- package/dist/clusterTestSuite.js +1 -1
- package/dist/index.d.ts +34 -0
- package/dist/index.js +2 -2
- package/dist/{src-B1XsZ6OO.js → src-CJ56XxpW.js} +401 -308
- package/package.json +4 -4
|
@@ -1,12 +1,12 @@
|
|
|
1
1
|
import { E as e, F as t, I as n, M as r, N as i, P as a, T as o, w as s } from "./primitives-B-HlFCap.js";
|
|
2
2
|
import { Activity as c, DurableClock as l, DurableDeferred as u, Workflow as d, WorkflowEngine as f } from "@effect/workflow";
|
|
3
3
|
import { Cause as p, Effect as m, Either as h, Exit as g, FiberRef as _, Layer as v, Schema as y } from "effect";
|
|
4
|
-
import { and as b, boolean as ee, eq as x, generateId as S, gt as C, gte as te, id as w, inSet as ne, integer as T, isNull as E, json as D, lt as O, or as
|
|
4
|
+
import { and as b, boolean as ee, eq as x, generateId as S, gt as C, gte as te, id as w, inSet as ne, integer as T, isNull as E, json as D, lt as O, or as re, queryFor as k, reference as A, registerRetention as ie, retentionTtlMsFromEnv as ae, table as j, text as M, timestamp as N } from "@voltro/database";
|
|
5
5
|
import { createHash as oe } from "node:crypto";
|
|
6
6
|
import { WorkflowInstance as se } from "@effect/workflow/WorkflowEngine";
|
|
7
7
|
import { publishServerError as ce } from "@voltro/protocol";
|
|
8
8
|
//#region src/inMemoryLayer.ts
|
|
9
|
-
var le = f.layerMemory,
|
|
9
|
+
var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
10
10
|
id: w({ prefix: "wfrun" }),
|
|
11
11
|
tag: M(),
|
|
12
12
|
executionId: M().unique(),
|
|
@@ -40,9 +40,9 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
40
40
|
"terminate",
|
|
41
41
|
"abandon"
|
|
42
42
|
]).nullable()
|
|
43
|
-
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]),
|
|
43
|
+
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), de = j("_voltro_workflow_run_steps", {
|
|
44
44
|
id: w({ prefix: "wfstep" }),
|
|
45
|
-
runId:
|
|
45
|
+
runId: A(() => ue, {
|
|
46
46
|
index: !1,
|
|
47
47
|
onDelete: "cascade"
|
|
48
48
|
}),
|
|
@@ -62,9 +62,9 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
62
62
|
startedAt: N().default("now"),
|
|
63
63
|
completedAt: N().nullable(),
|
|
64
64
|
durationMs: T().nullable()
|
|
65
|
-
}).index(["runId", "stepName"]).index(["startedAt"]),
|
|
65
|
+
}).index(["runId", "stepName"]).index(["startedAt"]), fe = j("_voltro_workflow_run_events", {
|
|
66
66
|
id: w({ prefix: "wfev" }),
|
|
67
|
-
runId:
|
|
67
|
+
runId: A(() => ue, {
|
|
68
68
|
index: !1,
|
|
69
69
|
onDelete: "cascade"
|
|
70
70
|
}),
|
|
@@ -73,7 +73,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
73
73
|
occurredAt: N().default("now"),
|
|
74
74
|
stepName: M().nullable(),
|
|
75
75
|
attempt: T().nullable()
|
|
76
|
-
}).index(["runId", "occurredAt"]).index(["eventType"]),
|
|
76
|
+
}).index(["runId", "occurredAt"]).index(["eventType"]), pe = j("_voltro_workflow_start_contexts", {
|
|
77
77
|
id: w({ prefix: "wfctx" }),
|
|
78
78
|
workflowName: M(),
|
|
79
79
|
executionId: M().unique(),
|
|
@@ -87,7 +87,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
87
87
|
"abandon"
|
|
88
88
|
]).nullable(),
|
|
89
89
|
createdAt: N().default("now")
|
|
90
|
-
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]),
|
|
90
|
+
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), me = j("_voltro_workflow_pending", {
|
|
91
91
|
id: w({ prefix: "wfp" }),
|
|
92
92
|
tenantId: M().nullable(),
|
|
93
93
|
workflowName: M(),
|
|
@@ -97,10 +97,13 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
97
97
|
"batch",
|
|
98
98
|
"throttle",
|
|
99
99
|
"concurrency",
|
|
100
|
-
"paused"
|
|
100
|
+
"paused",
|
|
101
|
+
"delayed"
|
|
101
102
|
]),
|
|
102
103
|
payload: D(),
|
|
103
104
|
callerContext: D().nullable(),
|
|
105
|
+
queuedAppVersion: M().nullable(),
|
|
106
|
+
queuedSchemaFingerprint: M().nullable(),
|
|
104
107
|
priority: T().default(0),
|
|
105
108
|
dueAt: N(),
|
|
106
109
|
deadlineAt: N().nullable(),
|
|
@@ -108,8 +111,9 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
108
111
|
firstSeenAt: N().default("now"),
|
|
109
112
|
updatedAt: N().default("now"),
|
|
110
113
|
attempts: T().default(0),
|
|
111
|
-
lastError: M().nullable()
|
|
112
|
-
|
|
114
|
+
lastError: M().nullable(),
|
|
115
|
+
deadLetteredAt: N().nullable()
|
|
116
|
+
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), he = j("_voltro_workflow_admissions", {
|
|
113
117
|
id: w({ prefix: "wfadm" }),
|
|
114
118
|
tenantId: M().nullable(),
|
|
115
119
|
workflowName: M(),
|
|
@@ -133,49 +137,49 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
133
137
|
admittedAt: N().default("now"),
|
|
134
138
|
expiresAt: N().nullable(),
|
|
135
139
|
releasedAt: N().nullable()
|
|
136
|
-
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]),
|
|
140
|
+
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), ge = j("_voltro_workflow_pauses", {
|
|
137
141
|
id: w({ prefix: "wfpause" }),
|
|
138
142
|
pausedAt: N().default("now"),
|
|
139
143
|
pausedBy: M().nullable(),
|
|
140
144
|
reason: M().nullable()
|
|
141
|
-
}),
|
|
145
|
+
}), _e = class extends Error {
|
|
142
146
|
workflowName;
|
|
143
147
|
field;
|
|
144
148
|
constructor(e, t, n) {
|
|
145
149
|
super(`workflow '${e}': ${t}(payload) threw — a flow-control key function must be total over every payload the workflow accepts, because it runs before the run exists and there is nowhere to report a partial failure to. Cause: ${n instanceof Error ? n.message : String(n)}`), this.name = "FlowControlKeyError", this.workflowName = e, this.field = t, this.cause = n;
|
|
146
150
|
}
|
|
147
|
-
},
|
|
151
|
+
}, P = (e, t, n, r) => {
|
|
148
152
|
try {
|
|
149
153
|
let e = n(r);
|
|
150
154
|
if (typeof e != "string" || e.length === 0) throw Error(`returned ${e === "" ? "an empty string" : String(e)}; expected a non-empty string`);
|
|
151
155
|
return e;
|
|
152
156
|
} catch (n) {
|
|
153
|
-
throw new
|
|
157
|
+
throw new _e(e, t, n);
|
|
154
158
|
}
|
|
155
|
-
},
|
|
159
|
+
}, ve = (e, t) => e === void 0 ? t : `pool\u0000${e}\u0000${t}`, F = (e, t) => {
|
|
156
160
|
let n = e.workflowName, r = 0;
|
|
157
161
|
if (e.priority !== void 0) try {
|
|
158
162
|
let n = e.priority(t);
|
|
159
163
|
if (!Number.isFinite(n)) throw Error(`returned ${String(n)}; expected a finite number`);
|
|
160
164
|
r = Math.trunc(n);
|
|
161
165
|
} catch (e) {
|
|
162
|
-
throw new
|
|
166
|
+
throw new _e(n, "priority", e);
|
|
163
167
|
}
|
|
164
168
|
return {
|
|
165
|
-
...e.debounce === void 0 ? {} : { debounceKey:
|
|
166
|
-
...e.singleton === void 0 ? {} : { singletonKey:
|
|
167
|
-
...e.concurrency === void 0 ? {} : { concurrencyKey:
|
|
168
|
-
...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey:
|
|
169
|
-
...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey:
|
|
170
|
-
...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey:
|
|
169
|
+
...e.debounce === void 0 ? {} : { debounceKey: P(n, "debounce.key", e.debounce.key, t) },
|
|
170
|
+
...e.singleton === void 0 ? {} : { singletonKey: P(n, "singleton.key", e.singleton.key, t) },
|
|
171
|
+
...e.concurrency === void 0 ? {} : { concurrencyKey: ve(e.concurrency.pool, e.concurrency.key === void 0 ? "" : P(n, "concurrency.key", e.concurrency.key, t)) },
|
|
172
|
+
...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: P(n, "throttle.key", e.throttle.key, t) },
|
|
173
|
+
...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: P(n, "rateLimit.key", e.rateLimit.key, t) },
|
|
174
|
+
...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey: P(n, "batch.key", e.batch.key, t) },
|
|
171
175
|
priority: r
|
|
172
176
|
};
|
|
173
|
-
},
|
|
177
|
+
}, ye = (e, t, n, r) => {
|
|
174
178
|
let i = e.filter((e) => e > r - n);
|
|
175
179
|
if (i.length < t) return;
|
|
176
180
|
let a = [...i].sort((e, t) => t - e)[t - 1];
|
|
177
181
|
if (a !== void 0) return a + n;
|
|
178
|
-
},
|
|
182
|
+
}, be = (e) => {
|
|
179
183
|
let { control: t, keys: n, state: r, now: i, reconsidering: a } = e;
|
|
180
184
|
if (r.paused === !0) return {
|
|
181
185
|
kind: "defer",
|
|
@@ -185,7 +189,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
185
189
|
keys: n
|
|
186
190
|
};
|
|
187
191
|
if (t.rateLimit !== void 0) {
|
|
188
|
-
let e =
|
|
192
|
+
let e = ye(r.recentAdmissions ?? [], t.rateLimit.limit, t.rateLimit.periodMs, i);
|
|
189
193
|
if (e !== void 0) return {
|
|
190
194
|
kind: "drop",
|
|
191
195
|
reason: "rate-limit",
|
|
@@ -204,12 +208,12 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
204
208
|
kind: "admit",
|
|
205
209
|
reason: "debounce-deadline",
|
|
206
210
|
keys: n,
|
|
207
|
-
...
|
|
211
|
+
...I(t, r)
|
|
208
212
|
} : {
|
|
209
213
|
kind: "admit",
|
|
210
214
|
reason: "debounce-elapsed",
|
|
211
215
|
keys: n,
|
|
212
|
-
...
|
|
216
|
+
...I(t, r)
|
|
213
217
|
} : {
|
|
214
218
|
kind: "defer",
|
|
215
219
|
mode: "debounce",
|
|
@@ -225,12 +229,12 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
225
229
|
kind: "admit",
|
|
226
230
|
reason: "batch-full",
|
|
227
231
|
keys: n,
|
|
228
|
-
...
|
|
232
|
+
...I(t, r)
|
|
229
233
|
} : a && i >= s ? {
|
|
230
234
|
kind: "admit",
|
|
231
235
|
reason: "batch-timeout",
|
|
232
236
|
keys: n,
|
|
233
|
-
...
|
|
237
|
+
...I(t, r)
|
|
234
238
|
} : {
|
|
235
239
|
kind: "defer",
|
|
236
240
|
mode: "batch",
|
|
@@ -240,7 +244,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
240
244
|
};
|
|
241
245
|
}
|
|
242
246
|
if (t.throttle !== void 0) {
|
|
243
|
-
let e =
|
|
247
|
+
let e = ye(r.recentAdmissions ?? [], t.throttle.limit, t.throttle.periodMs, i);
|
|
244
248
|
if (e !== void 0) return {
|
|
245
249
|
kind: "defer",
|
|
246
250
|
mode: "throttle",
|
|
@@ -257,25 +261,25 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
257
261
|
keys: n
|
|
258
262
|
} : {
|
|
259
263
|
kind: "admit",
|
|
260
|
-
reason:
|
|
264
|
+
reason: xe(t) ? "under-limits" : "no-controls",
|
|
261
265
|
keys: n,
|
|
262
|
-
...
|
|
266
|
+
...I(t, r)
|
|
263
267
|
};
|
|
264
|
-
},
|
|
268
|
+
}, xe = (e) => e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0, I = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, Se = (e, t, n) => {
|
|
265
269
|
let r = e.timeouts?.startMs;
|
|
266
270
|
return r !== void 0 && n - t.firstSeenAt >= r;
|
|
267
|
-
},
|
|
271
|
+
}, Ce = (e, t, n) => {
|
|
268
272
|
let r = e.timeouts?.finishMs;
|
|
269
273
|
return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
|
|
270
|
-
},
|
|
274
|
+
}, we = (e, t) => e.priority === t.priority ? e.firstSeenAt === t.firstSeenAt ? e.id < t.id ? -1 : +(e.id > t.id) : e.firstSeenAt - t.firstSeenAt : t.priority - e.priority, L = "_voltro_workflow_pending", R = "_voltro_workflow_admissions", Te = "_voltro_workflow_pauses", Ee = 864e5, De = (e, t, n) => `wfp_${oe("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, z = (e) => {
|
|
271
275
|
if (e instanceof Date) return e.getTime();
|
|
272
276
|
if (typeof e == "number") return e;
|
|
273
277
|
let t = Date.parse(String(e));
|
|
274
278
|
return Number.isNaN(t) ? 0 : t;
|
|
275
|
-
},
|
|
279
|
+
}, B = (e, t) => {
|
|
276
280
|
let n = typeof e == "number" ? e : Number(e);
|
|
277
281
|
return Number.isFinite(n) ? Math.trunc(n) : t;
|
|
278
|
-
},
|
|
282
|
+
}, Oe = (e) => ({
|
|
279
283
|
id: String(e.id),
|
|
280
284
|
tenantId: e.tenantId === null || e.tenantId === void 0 ? null : String(e.tenantId),
|
|
281
285
|
workflowName: String(e.workflowName),
|
|
@@ -283,25 +287,28 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
283
287
|
mode: String(e.mode),
|
|
284
288
|
payload: e.payload,
|
|
285
289
|
callerContext: e.callerContext ?? null,
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
290
|
+
queuedAppVersion: e.queuedAppVersion === null || e.queuedAppVersion === void 0 ? null : String(e.queuedAppVersion),
|
|
291
|
+
queuedSchemaFingerprint: e.queuedSchemaFingerprint === null || e.queuedSchemaFingerprint === void 0 ? null : String(e.queuedSchemaFingerprint),
|
|
292
|
+
priority: B(e.priority, 0),
|
|
293
|
+
dueAt: z(e.dueAt),
|
|
294
|
+
deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : z(e.deadlineAt),
|
|
295
|
+
collapsed: B(e.collapsed, 1),
|
|
296
|
+
firstSeenAt: z(e.firstSeenAt),
|
|
297
|
+
attempts: B(e.attempts, 0),
|
|
298
|
+
lastError: e.lastError === null || e.lastError === void 0 ? null : String(e.lastError),
|
|
299
|
+
deadLetteredAt: e.deadLetteredAt === null || e.deadLetteredAt === void 0 ? void 0 : z(e.deadLetteredAt)
|
|
300
|
+
}), V = (e, t, n, r) => ({
|
|
294
301
|
table: e,
|
|
295
302
|
predicate: t,
|
|
296
303
|
order: n,
|
|
297
304
|
take: r,
|
|
298
305
|
skip: void 0,
|
|
299
306
|
projection: void 0
|
|
300
|
-
}),
|
|
301
|
-
let t = await e.query(
|
|
307
|
+
}), ke = async (e) => {
|
|
308
|
+
let t = await e.query(V(Te, void 0, [], 1e3));
|
|
302
309
|
return new Set(t.map((e) => String(e.id)));
|
|
303
|
-
},
|
|
304
|
-
await e.upsert(
|
|
310
|
+
}, Ae = async (e, t, n, r) => {
|
|
311
|
+
await e.upsert(Te, {
|
|
305
312
|
id: t,
|
|
306
313
|
pausedAt: /* @__PURE__ */ new Date(),
|
|
307
314
|
pausedBy: n,
|
|
@@ -314,43 +321,43 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
314
321
|
"reason"
|
|
315
322
|
]
|
|
316
323
|
});
|
|
317
|
-
},
|
|
324
|
+
}, je = async (e, t) => e.delete(Te, t), Me = async (e) => {
|
|
318
325
|
let { store: t, control: n, keys: r, now: i } = e, a = { paused: e.paused }, o = [];
|
|
319
326
|
n.debounce !== void 0 && r.debounceKey !== void 0 && o.push((async () => {
|
|
320
|
-
let e = (await t.query(
|
|
327
|
+
let e = (await t.query(V(L, b(x("workflowName", n.workflowName), x("controlKey", r.debounceKey), x("mode", "debounce")), [], 1)))[0];
|
|
321
328
|
if (e === void 0) return;
|
|
322
|
-
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 :
|
|
329
|
+
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : z(e.deadlineAt);
|
|
323
330
|
a.debouncePending = {
|
|
324
|
-
firstSeenAt:
|
|
325
|
-
collapsed:
|
|
331
|
+
firstSeenAt: z(e.firstSeenAt),
|
|
332
|
+
collapsed: B(e.collapsed, 1),
|
|
326
333
|
...i === void 0 ? {} : { deadlineAt: i }
|
|
327
334
|
};
|
|
328
335
|
})()), n.batch !== void 0 && r.batchKey !== void 0 && o.push((async () => {
|
|
329
|
-
let e = await t.query(
|
|
336
|
+
let e = await t.query(V(L, b(x("workflowName", n.workflowName), x("controlKey", r.batchKey), x("mode", "batch")), [{
|
|
330
337
|
column: "firstSeenAt",
|
|
331
338
|
direction: "asc"
|
|
332
339
|
}], n.batch.maxSize + 1));
|
|
333
340
|
e.length !== 0 && (a.batchPending = {
|
|
334
341
|
count: e.length,
|
|
335
|
-
firstSeenAt:
|
|
342
|
+
firstSeenAt: z(e[0].firstSeenAt)
|
|
336
343
|
});
|
|
337
344
|
})()), n.singleton !== void 0 && r.singletonKey !== void 0 && o.push((async () => {
|
|
338
|
-
let e = await
|
|
345
|
+
let e = await Ne(t, n.workflowName, r.singletonKey, i);
|
|
339
346
|
e !== void 0 && (a.singletonHolder = e);
|
|
340
347
|
})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && o.push((async () => {
|
|
341
|
-
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(
|
|
348
|
+
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(V(R, b(...e, x("concurrencyKey", r.concurrencyKey), E("releasedAt"), C("expiresAt", new Date(i))), [], n.concurrency.limit));
|
|
342
349
|
a.inFlight = o.length;
|
|
343
350
|
})());
|
|
344
351
|
let s = n.rateLimit ?? n.throttle, c = r.rateLimitKey ?? r.throttleKey;
|
|
345
352
|
return s !== void 0 && c !== void 0 && o.push((async () => {
|
|
346
|
-
let e = await t.query(
|
|
353
|
+
let e = await t.query(V(R, b(x("workflowName", n.workflowName), x("rateKey", c), x("outcome", "admitted"), C("admittedAt", new Date(i - s.periodMs))), [{
|
|
347
354
|
column: "admittedAt",
|
|
348
355
|
direction: "desc"
|
|
349
356
|
}], s.limit));
|
|
350
|
-
a.recentAdmissions = e.map((e) =>
|
|
357
|
+
a.recentAdmissions = e.map((e) => z(e.admittedAt));
|
|
351
358
|
})()), await Promise.all(o), a;
|
|
352
|
-
},
|
|
353
|
-
let i = (await e.query(
|
|
359
|
+
}, Ne = async (e, t, n, r) => {
|
|
360
|
+
let i = (await e.query(V(R, b(x("workflowName", t), x("singletonKey", n), E("releasedAt"), C("expiresAt", new Date(r))), [{
|
|
354
361
|
column: "admittedAt",
|
|
355
362
|
direction: "desc"
|
|
356
363
|
}], 1)))[0];
|
|
@@ -359,20 +366,20 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
359
366
|
if (a != null) return {
|
|
360
367
|
executionId: String(a),
|
|
361
368
|
runId: i.runId === null || i.runId === void 0 ? "" : String(i.runId),
|
|
362
|
-
admittedAt:
|
|
369
|
+
admittedAt: z(i.admittedAt)
|
|
363
370
|
};
|
|
364
|
-
},
|
|
365
|
-
let { store: t, control: n, decision: r, now: i } = e, a =
|
|
371
|
+
}, Pe = async (e) => {
|
|
372
|
+
let { store: t, control: n, decision: r, now: i } = e, a = Ie(r.mode, r.keys);
|
|
366
373
|
if (r.collapse === "hold") {
|
|
367
|
-
let o = e.existingId ??
|
|
368
|
-
return await t.update(
|
|
374
|
+
let o = e.existingId ?? De(n.workflowName, r.mode, a);
|
|
375
|
+
return await t.update(L, o, {
|
|
369
376
|
dueAt: new Date(r.dueAt),
|
|
370
377
|
updatedAt: new Date(i)
|
|
371
378
|
}), o;
|
|
372
379
|
}
|
|
373
380
|
if (r.collapse === "replace") {
|
|
374
|
-
let o =
|
|
375
|
-
return await t.upsert(
|
|
381
|
+
let o = De(n.workflowName, r.mode, a);
|
|
382
|
+
return await t.upsert(L, {
|
|
376
383
|
id: o,
|
|
377
384
|
tenantId: e.tenantId,
|
|
378
385
|
workflowName: n.workflowName,
|
|
@@ -380,6 +387,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
380
387
|
mode: r.mode,
|
|
381
388
|
payload: e.payload,
|
|
382
389
|
callerContext: e.callerContext ?? null,
|
|
390
|
+
queuedAppVersion: e.queuedAppVersion ?? null,
|
|
391
|
+
queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
|
|
383
392
|
priority: r.keys.priority,
|
|
384
393
|
dueAt: new Date(r.dueAt),
|
|
385
394
|
deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
|
|
@@ -387,27 +396,35 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
387
396
|
firstSeenAt: new Date(i),
|
|
388
397
|
updatedAt: new Date(i),
|
|
389
398
|
attempts: 0,
|
|
390
|
-
lastError: null
|
|
399
|
+
lastError: null,
|
|
400
|
+
deadLetteredAt: null
|
|
391
401
|
}, {
|
|
392
402
|
conflictColumns: ["id"],
|
|
393
403
|
update: (t) => ({
|
|
394
404
|
payload: e.payload,
|
|
395
405
|
callerContext: e.callerContext ?? null,
|
|
406
|
+
queuedAppVersion: e.queuedAppVersion ?? null,
|
|
407
|
+
queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
|
|
396
408
|
priority: r.keys.priority,
|
|
397
409
|
dueAt: new Date(r.dueAt),
|
|
398
410
|
deadlineAt: r.deadlineAt === void 0 ? t.deadlineAt ?? null : new Date(r.deadlineAt),
|
|
399
|
-
collapsed:
|
|
400
|
-
updatedAt: new Date(i)
|
|
411
|
+
collapsed: B(t.collapsed, 1) + 1,
|
|
412
|
+
updatedAt: new Date(i),
|
|
413
|
+
attempts: 0,
|
|
414
|
+
lastError: null,
|
|
415
|
+
deadLetteredAt: null
|
|
401
416
|
})
|
|
402
417
|
}), o;
|
|
403
418
|
}
|
|
404
|
-
let o = await t.insert(
|
|
419
|
+
let o = await t.insert(L, {
|
|
405
420
|
tenantId: e.tenantId,
|
|
406
421
|
workflowName: n.workflowName,
|
|
407
422
|
controlKey: a,
|
|
408
423
|
mode: r.mode,
|
|
409
424
|
payload: e.payload,
|
|
410
425
|
callerContext: e.callerContext ?? null,
|
|
426
|
+
queuedAppVersion: e.queuedAppVersion ?? null,
|
|
427
|
+
queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
|
|
411
428
|
priority: r.keys.priority,
|
|
412
429
|
dueAt: new Date(r.dueAt),
|
|
413
430
|
deadlineAt: r.deadlineAt === void 0 ? null : new Date(r.deadlineAt),
|
|
@@ -415,17 +432,20 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
415
432
|
firstSeenAt: new Date(i),
|
|
416
433
|
updatedAt: new Date(i),
|
|
417
434
|
attempts: 0,
|
|
418
|
-
lastError: null
|
|
435
|
+
lastError: null,
|
|
436
|
+
deadLetteredAt: null
|
|
419
437
|
});
|
|
420
438
|
return String(o.id);
|
|
421
|
-
},
|
|
422
|
-
let t = await e.store.insert(
|
|
439
|
+
}, Fe = async (e) => {
|
|
440
|
+
let t = await e.store.insert(L, {
|
|
423
441
|
tenantId: e.tenantId,
|
|
424
442
|
workflowName: e.workflowName,
|
|
425
443
|
controlKey: "",
|
|
426
444
|
mode: "delayed",
|
|
427
445
|
payload: e.payload,
|
|
428
446
|
callerContext: e.callerContext ?? null,
|
|
447
|
+
queuedAppVersion: e.queuedAppVersion ?? null,
|
|
448
|
+
queuedSchemaFingerprint: e.queuedSchemaFingerprint ?? null,
|
|
429
449
|
priority: 0,
|
|
430
450
|
dueAt: new Date(e.at),
|
|
431
451
|
deadlineAt: null,
|
|
@@ -433,13 +453,14 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
433
453
|
firstSeenAt: new Date(e.now),
|
|
434
454
|
updatedAt: new Date(e.now),
|
|
435
455
|
attempts: 0,
|
|
436
|
-
lastError: null
|
|
456
|
+
lastError: null,
|
|
457
|
+
deadLetteredAt: null
|
|
437
458
|
});
|
|
438
459
|
return {
|
|
439
460
|
intentId: String(t.id),
|
|
440
461
|
dueAt: e.at
|
|
441
462
|
};
|
|
442
|
-
},
|
|
463
|
+
}, Ie = (e, t) => {
|
|
443
464
|
switch (e) {
|
|
444
465
|
case "debounce": return t.debounceKey ?? "";
|
|
445
466
|
case "batch": return t.batchKey ?? "";
|
|
@@ -447,8 +468,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
447
468
|
case "concurrency": return t.concurrencyKey ?? "";
|
|
448
469
|
default: return "";
|
|
449
470
|
}
|
|
450
|
-
},
|
|
451
|
-
let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(
|
|
471
|
+
}, H = async (e) => {
|
|
472
|
+
let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(R, {
|
|
452
473
|
tenantId: e.tenantId,
|
|
453
474
|
workflowName: t.workflowName,
|
|
454
475
|
outcome: e.outcome,
|
|
@@ -466,31 +487,31 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
466
487
|
releasedAt: e.outcome === "admitted" ? null : new Date(r)
|
|
467
488
|
});
|
|
468
489
|
return String(a.id);
|
|
469
|
-
},
|
|
470
|
-
let r = await e.query(
|
|
471
|
-
return r.length !== 0 && (await Promise.all(r.map((t) => e.update(
|
|
472
|
-
},
|
|
473
|
-
let r = (await e.query(
|
|
490
|
+
}, Le = async (e, t, n) => {
|
|
491
|
+
let r = await e.query(V(R, b(x("executionId", t), x("outcome", "admitted"), E("releasedAt")), [], 10));
|
|
492
|
+
return r.length !== 0 && (await Promise.all(r.map((t) => e.update(R, String(t.id), { releasedAt: new Date(n) }))), !0);
|
|
493
|
+
}, Re = async (e, t, n) => (await ze(e, t, n)).due, ze = async (e, t, n) => {
|
|
494
|
+
let r = (await e.query(V(L, E("deadLetteredAt"), [{
|
|
474
495
|
column: "priority",
|
|
475
496
|
direction: "desc"
|
|
476
497
|
}, {
|
|
477
498
|
column: "firstSeenAt",
|
|
478
499
|
direction: "asc"
|
|
479
|
-
}], n))).map(
|
|
500
|
+
}], n))).map(Oe), i;
|
|
480
501
|
for (let e of r) e.dueAt <= t || (i === void 0 || e.dueAt < i) && (i = e.dueAt);
|
|
481
502
|
return {
|
|
482
|
-
due: r.filter((e) => e.dueAt <= t).sort(
|
|
503
|
+
due: r.filter((e) => e.dueAt <= t).sort(we),
|
|
483
504
|
nextDueAt: i
|
|
484
505
|
};
|
|
485
|
-
},
|
|
506
|
+
}, Be = async (e, t) => (await e.query(V(L, void 0, [{
|
|
486
507
|
column: "firstSeenAt",
|
|
487
508
|
direction: "asc"
|
|
488
|
-
}], t))).map(
|
|
489
|
-
let i = (await e.query(
|
|
509
|
+
}], t))).map(Oe), U = async (e, t) => e.delete(L, t), Ve = async (e, t, n, r) => {
|
|
510
|
+
let i = (await e.query(V(L, x("id", t), [], 1)))[0];
|
|
490
511
|
if (i === void 0) return !1;
|
|
491
|
-
let a =
|
|
512
|
+
let a = Oe(i);
|
|
492
513
|
try {
|
|
493
|
-
await e.insert(
|
|
514
|
+
await e.insert(R, {
|
|
494
515
|
tenantId: a.tenantId,
|
|
495
516
|
workflowName: a.workflowName,
|
|
496
517
|
outcome: "discarded",
|
|
@@ -508,36 +529,50 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
508
529
|
releasedAt: new Date(r)
|
|
509
530
|
});
|
|
510
531
|
} catch {}
|
|
511
|
-
return e.delete(
|
|
512
|
-
},
|
|
513
|
-
await e.update(
|
|
532
|
+
return e.delete(L, t);
|
|
533
|
+
}, W = async (e, t, n, r) => {
|
|
534
|
+
await e.update(L, t.id, {
|
|
514
535
|
attempts: t.attempts + 1,
|
|
515
536
|
lastError: n.slice(0, 500),
|
|
516
537
|
updatedAt: new Date(r)
|
|
517
538
|
});
|
|
518
|
-
},
|
|
519
|
-
|
|
539
|
+
}, He = async (e, t, n, r) => await e.update(L, t.id, {
|
|
540
|
+
attempts: t.attempts + 1,
|
|
541
|
+
lastError: n.slice(0, 500),
|
|
542
|
+
deadLetteredAt: new Date(r),
|
|
543
|
+
updatedAt: new Date(r)
|
|
544
|
+
}) !== null, Ue = async (e, t, n) => {
|
|
545
|
+
let r = (await e.query(V(L, x("id", t), [], 1)))[0];
|
|
546
|
+
return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(L, t, {
|
|
547
|
+
attempts: 0,
|
|
548
|
+
lastError: null,
|
|
549
|
+
deadLetteredAt: null,
|
|
550
|
+
dueAt: new Date(n),
|
|
551
|
+
updatedAt: new Date(n)
|
|
552
|
+
}) !== null;
|
|
553
|
+
}, We = async (e) => {
|
|
554
|
+
let t = await Me({
|
|
520
555
|
store: e.store,
|
|
521
556
|
control: e.control,
|
|
522
557
|
keys: e.keys,
|
|
523
558
|
now: e.now,
|
|
524
559
|
paused: e.paused
|
|
525
560
|
});
|
|
526
|
-
return
|
|
561
|
+
return be({
|
|
527
562
|
control: e.control,
|
|
528
563
|
keys: e.keys,
|
|
529
564
|
state: t,
|
|
530
565
|
now: e.now,
|
|
531
566
|
reconsidering: e.reconsidering
|
|
532
567
|
});
|
|
533
|
-
},
|
|
534
|
-
let r = await e.query(
|
|
568
|
+
}, Ge = async (e, t, n = 1e3) => {
|
|
569
|
+
let r = await e.query(V(R, void 0, [{
|
|
535
570
|
column: "admittedAt",
|
|
536
571
|
direction: "asc"
|
|
537
|
-
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null &&
|
|
538
|
-
return await Promise.all(a.map((t) => e.delete(
|
|
539
|
-
},
|
|
540
|
-
let { store: t, control: n, now: r } = e, i =
|
|
572
|
+
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && z(e.admittedAt) < i);
|
|
573
|
+
return await Promise.all(a.map((t) => e.delete(R, String(t.id)))), a.length;
|
|
574
|
+
}, Ke = async (e) => {
|
|
575
|
+
let { store: t, control: n, now: r } = e, i = F(n, e.payload), a = await We({
|
|
541
576
|
store: t,
|
|
542
577
|
control: n,
|
|
543
578
|
keys: i,
|
|
@@ -545,7 +580,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
545
580
|
now: r,
|
|
546
581
|
reconsidering: !1
|
|
547
582
|
});
|
|
548
|
-
if (a.kind === "drop") return await
|
|
583
|
+
if (a.kind === "drop") return await H({
|
|
549
584
|
store: t,
|
|
550
585
|
control: n,
|
|
551
586
|
keys: i,
|
|
@@ -562,7 +597,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
562
597
|
kind: "dropped",
|
|
563
598
|
retryAfterMs: a.retryAfterMs
|
|
564
599
|
};
|
|
565
|
-
if (a.kind === "skip") return await
|
|
600
|
+
if (a.kind === "skip") return await H({
|
|
566
601
|
store: t,
|
|
567
602
|
control: n,
|
|
568
603
|
keys: i,
|
|
@@ -582,26 +617,28 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
582
617
|
};
|
|
583
618
|
if (a.kind === "defer") return {
|
|
584
619
|
kind: "queued",
|
|
585
|
-
intentId: await
|
|
620
|
+
intentId: await Pe({
|
|
586
621
|
store: t,
|
|
587
622
|
control: n,
|
|
588
623
|
decision: a,
|
|
589
624
|
payload: e.payload,
|
|
590
625
|
callerContext: e.callerContext,
|
|
591
626
|
tenantId: e.tenantId,
|
|
592
|
-
now: r
|
|
627
|
+
now: r,
|
|
628
|
+
...e.queuedAppVersion === void 0 ? {} : { queuedAppVersion: e.queuedAppVersion },
|
|
629
|
+
...e.queuedSchemaFingerprint === void 0 ? {} : { queuedSchemaFingerprint: e.queuedSchemaFingerprint }
|
|
593
630
|
}),
|
|
594
631
|
mode: a.mode,
|
|
595
632
|
dueAt: a.dueAt
|
|
596
633
|
};
|
|
597
634
|
let o = e.payload, s = [], c = 1;
|
|
598
635
|
if (n.batch !== void 0 && i.batchKey !== void 0) {
|
|
599
|
-
let r = await
|
|
636
|
+
let r = await qe(t, n.workflowName, i.batchKey, n.batch.maxSize);
|
|
600
637
|
o = { items: [...r.map((e) => e.payload), e.payload] }, s = r.map((e) => e.id), c = r.length + 1;
|
|
601
638
|
}
|
|
602
639
|
return {
|
|
603
640
|
kind: "start",
|
|
604
|
-
ledgerId: await
|
|
641
|
+
ledgerId: await H({
|
|
605
642
|
store: t,
|
|
606
643
|
control: n,
|
|
607
644
|
keys: i,
|
|
@@ -624,7 +661,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
624
661
|
runId: a.evict.runId
|
|
625
662
|
} }
|
|
626
663
|
};
|
|
627
|
-
},
|
|
664
|
+
}, qe = async (e, t, n, r) => (await e.query({
|
|
628
665
|
table: "_voltro_workflow_pending",
|
|
629
666
|
predicate: b(x("workflowName", t), x("controlKey", n), x("mode", "batch")),
|
|
630
667
|
order: [{
|
|
@@ -637,22 +674,22 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
637
674
|
})).map((e) => ({
|
|
638
675
|
id: String(e.id),
|
|
639
676
|
payload: e.payload
|
|
640
|
-
})),
|
|
677
|
+
})), Je = async (e, t, n, r) => {
|
|
641
678
|
await e.update("_voltro_workflow_admissions", t, {
|
|
642
679
|
executionId: n,
|
|
643
680
|
runId: r
|
|
644
681
|
});
|
|
645
|
-
},
|
|
682
|
+
}, Ye = j("_voltro_workflow_watermarks", {
|
|
646
683
|
id: w({ prefix: "wfwm" }),
|
|
647
684
|
positionAt: N(),
|
|
648
685
|
updatedAt: N().default("now")
|
|
649
|
-
}),
|
|
686
|
+
}), Xe = (e) => {
|
|
650
687
|
let t = e instanceof Error ? e.message : String(e);
|
|
651
688
|
return t.length > 400 ? `${t.slice(0, 400)}…` : t;
|
|
652
|
-
},
|
|
689
|
+
}, Ze = (e) => {
|
|
653
690
|
let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => h.right(e) : (t) => {
|
|
654
691
|
let n = y.decodeUnknownEither(e.payloadSchema)(t);
|
|
655
|
-
return h.isRight(n) ? h.right(n.right) : h.left(
|
|
692
|
+
return h.isRight(n) ? h.right(n.right) : h.left(Xe(n.left));
|
|
656
693
|
}, s = e.runs.map((e) => ({
|
|
657
694
|
run: e,
|
|
658
695
|
decoded: o(e.payload)
|
|
@@ -669,7 +706,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
669
706
|
workflowName: e.workflowName,
|
|
670
707
|
event: o.event,
|
|
671
708
|
subject: l.id,
|
|
672
|
-
detail:
|
|
709
|
+
detail: Xe(u.left)
|
|
673
710
|
});
|
|
674
711
|
continue;
|
|
675
712
|
}
|
|
@@ -689,7 +726,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
689
726
|
workflowName: e.workflowName,
|
|
690
727
|
event: o.event,
|
|
691
728
|
subject: n,
|
|
692
|
-
detail:
|
|
729
|
+
detail: Xe(t)
|
|
693
730
|
}), !1;
|
|
694
731
|
}
|
|
695
732
|
};
|
|
@@ -712,33 +749,33 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
712
749
|
discards: n,
|
|
713
750
|
problems: r
|
|
714
751
|
};
|
|
715
|
-
},
|
|
752
|
+
}, Qe = (e) => {
|
|
716
753
|
let t;
|
|
717
754
|
for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
|
|
718
755
|
return t;
|
|
719
|
-
},
|
|
756
|
+
}, $e = "_voltro_workflow_watermarks", et = "_voltro_workflow_events", G = "cancelOn", tt = 36e5, nt = 500, K = (e) => {
|
|
720
757
|
if (e instanceof Date) return e;
|
|
721
758
|
if (typeof e == "number") return new Date(e);
|
|
722
759
|
if (typeof e == "string") {
|
|
723
760
|
let t = new Date(e);
|
|
724
761
|
if (!Number.isNaN(t.getTime())) return t;
|
|
725
762
|
}
|
|
726
|
-
},
|
|
727
|
-
table:
|
|
763
|
+
}, q = (e) => e instanceof Error ? e.message : String(e), rt = async (e, t) => K((await e.query({
|
|
764
|
+
table: $e,
|
|
728
765
|
predicate: x("id", t),
|
|
729
766
|
order: [],
|
|
730
767
|
take: 1,
|
|
731
768
|
skip: void 0,
|
|
732
769
|
projection: void 0
|
|
733
|
-
}))[0]?.positionAt),
|
|
734
|
-
await e.upsert(
|
|
770
|
+
}))[0]?.positionAt), it = async (e, t, n) => {
|
|
771
|
+
await e.upsert($e, {
|
|
735
772
|
id: t,
|
|
736
773
|
positionAt: n,
|
|
737
774
|
updatedAt: /* @__PURE__ */ new Date()
|
|
738
775
|
}, {
|
|
739
776
|
conflictColumns: ["id"],
|
|
740
777
|
update: (e) => {
|
|
741
|
-
let t =
|
|
778
|
+
let t = K(e.positionAt);
|
|
742
779
|
return t !== void 0 && t.getTime() >= n.getTime() ? {
|
|
743
780
|
positionAt: t,
|
|
744
781
|
updatedAt: /* @__PURE__ */ new Date()
|
|
@@ -748,7 +785,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
748
785
|
};
|
|
749
786
|
}
|
|
750
787
|
});
|
|
751
|
-
},
|
|
788
|
+
}, at = async (e, t, n) => {
|
|
752
789
|
let r = async (r) => e.query({
|
|
753
790
|
table: "_voltro_workflow_runs",
|
|
754
791
|
predicate: b(x("tag", t), x("status", r)),
|
|
@@ -761,7 +798,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
761
798
|
projection: void 0
|
|
762
799
|
});
|
|
763
800
|
return [...await r("running"), ...await r("suspended")].flatMap((e) => {
|
|
764
|
-
let t = e, n =
|
|
801
|
+
let t = e, n = K(t.startedAt);
|
|
765
802
|
return typeof t.id != "string" || typeof t.executionId != "string" || n === void 0 ? [] : [{
|
|
766
803
|
runId: t.id,
|
|
767
804
|
executionId: t.executionId,
|
|
@@ -769,7 +806,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
769
806
|
startedAt: n
|
|
770
807
|
}];
|
|
771
808
|
});
|
|
772
|
-
},
|
|
809
|
+
}, ot = async (e, t, n) => (await e.query({
|
|
773
810
|
table: "_voltro_workflow_pending",
|
|
774
811
|
predicate: x("workflowName", t),
|
|
775
812
|
order: [{
|
|
@@ -780,13 +817,13 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
780
817
|
skip: void 0,
|
|
781
818
|
projection: void 0
|
|
782
819
|
})).flatMap((e) => {
|
|
783
|
-
let t = e, n =
|
|
820
|
+
let t = e, n = K(t.firstSeenAt);
|
|
784
821
|
return typeof t.id != "string" || n === void 0 ? [] : [{
|
|
785
822
|
intentId: t.id,
|
|
786
823
|
payload: t.payload,
|
|
787
824
|
firstSeenAt: n
|
|
788
825
|
}];
|
|
789
|
-
}),
|
|
826
|
+
}), st = async (e, t) => {
|
|
790
827
|
let n = t.workflows.filter((e) => e.entries.length > 0);
|
|
791
828
|
if (n.length === 0) return {
|
|
792
829
|
examined: !1,
|
|
@@ -801,8 +838,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
801
838
|
};
|
|
802
839
|
let r = e.now?.() ?? Date.now(), i = t.batch ?? 500, a = t.coldLookbackMs ?? 36e5, o = /* @__PURE__ */ new Set();
|
|
803
840
|
for (let e of n) for (let t of e.entries) o.add(t.event);
|
|
804
|
-
let s = await
|
|
805
|
-
table:
|
|
841
|
+
let s = await rt(e.store, G), c = s ?? new Date(r - a), l = await e.store.query({
|
|
842
|
+
table: et,
|
|
806
843
|
predicate: te("occurredAt", c),
|
|
807
844
|
order: [{
|
|
808
845
|
column: "occurredAt",
|
|
@@ -813,7 +850,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
813
850
|
projection: void 0
|
|
814
851
|
}), u = [];
|
|
815
852
|
for (let e of l) {
|
|
816
|
-
let t = e, n =
|
|
853
|
+
let t = e, n = K(t.occurredAt);
|
|
817
854
|
typeof t.id == "string" && typeof t.name == "string" && n !== void 0 && o.has(t.name) && u.push({
|
|
818
855
|
id: t.id,
|
|
819
856
|
name: t.name,
|
|
@@ -827,15 +864,15 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
827
864
|
if (n.length === 0) continue;
|
|
828
865
|
let r = [], i = [];
|
|
829
866
|
try {
|
|
830
|
-
r = await
|
|
867
|
+
r = await at(e.store, t.workflowName, _), i = await ot(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
|
|
831
868
|
} catch (e) {
|
|
832
869
|
f.push({
|
|
833
870
|
subject: t.workflowName,
|
|
834
|
-
detail:
|
|
871
|
+
detail: q(e)
|
|
835
872
|
}), g = !0;
|
|
836
873
|
continue;
|
|
837
874
|
}
|
|
838
|
-
let a =
|
|
875
|
+
let a = Ze({
|
|
839
876
|
workflowName: t.workflowName,
|
|
840
877
|
entries: t.entries,
|
|
841
878
|
payloadSchema: t.payloadSchema,
|
|
@@ -860,7 +897,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
860
897
|
} catch (e) {
|
|
861
898
|
f.push({
|
|
862
899
|
subject: n.runId,
|
|
863
|
-
detail:
|
|
900
|
+
detail: q(e)
|
|
864
901
|
});
|
|
865
902
|
}
|
|
866
903
|
for (let n of a.discards) try {
|
|
@@ -873,26 +910,26 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
873
910
|
} catch (e) {
|
|
874
911
|
f.push({
|
|
875
912
|
subject: n.intentId,
|
|
876
|
-
detail:
|
|
913
|
+
detail: q(e)
|
|
877
914
|
});
|
|
878
915
|
}
|
|
879
916
|
}
|
|
880
|
-
let v =
|
|
917
|
+
let v = Qe(u), y = s;
|
|
881
918
|
if (g) e.log?.warn("workflow.cancelOn: holding the watermark — some workflows could not be evaluated", { failures: f.length });
|
|
882
919
|
else if (v !== void 0) try {
|
|
883
|
-
await
|
|
920
|
+
await it(e.store, G, v), y = v;
|
|
884
921
|
} catch (e) {
|
|
885
922
|
f.push({
|
|
886
|
-
subject:
|
|
887
|
-
detail:
|
|
923
|
+
subject: G,
|
|
924
|
+
detail: q(e)
|
|
888
925
|
});
|
|
889
926
|
}
|
|
890
927
|
else if (s === void 0) try {
|
|
891
|
-
await
|
|
928
|
+
await it(e.store, G, c), y = c;
|
|
892
929
|
} catch (e) {
|
|
893
930
|
f.push({
|
|
894
|
-
subject:
|
|
895
|
-
detail:
|
|
931
|
+
subject: G,
|
|
932
|
+
detail: q(e)
|
|
896
933
|
});
|
|
897
934
|
}
|
|
898
935
|
return d.length > 0 && e.log?.warn("workflow.cancelOn: some events could not be evaluated", {
|
|
@@ -909,14 +946,14 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
909
946
|
failures: f,
|
|
910
947
|
watermark: y
|
|
911
948
|
};
|
|
912
|
-
},
|
|
949
|
+
}, ct = 18e5, lt = 200, ut = 20, J = (e) => {
|
|
913
950
|
if (e instanceof Date) return e;
|
|
914
951
|
if (typeof e == "number") return new Date(e);
|
|
915
952
|
if (typeof e == "string") {
|
|
916
953
|
let t = new Date(e);
|
|
917
954
|
if (!Number.isNaN(t.getTime())) return t;
|
|
918
955
|
}
|
|
919
|
-
},
|
|
956
|
+
}, dt = (e) => e instanceof Error ? e.message : String(e), ft = async (e, t, n) => (await e.query({
|
|
920
957
|
table: "_voltro_workflow_run_events",
|
|
921
958
|
predicate: x("runId", t),
|
|
922
959
|
order: [{
|
|
@@ -927,13 +964,13 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
927
964
|
skip: void 0,
|
|
928
965
|
projection: void 0
|
|
929
966
|
})).flatMap((e) => {
|
|
930
|
-
let t = e, n =
|
|
967
|
+
let t = e, n = J(t.occurredAt);
|
|
931
968
|
return typeof t.eventType != "string" || n === void 0 ? [] : [{
|
|
932
969
|
eventType: t.eventType,
|
|
933
970
|
occurredAt: n,
|
|
934
971
|
payload: t.payload
|
|
935
972
|
}];
|
|
936
|
-
}),
|
|
973
|
+
}), pt = async (e, t) => {
|
|
937
974
|
let n = (await e.query({
|
|
938
975
|
table: "_voltro_workflow_run_steps",
|
|
939
976
|
predicate: x("runId", t),
|
|
@@ -946,24 +983,24 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
946
983
|
projection: void 0
|
|
947
984
|
}))[0];
|
|
948
985
|
if (n === void 0) return;
|
|
949
|
-
let r =
|
|
986
|
+
let r = J(n.startedAt), i = J(n.completedAt);
|
|
950
987
|
return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
|
|
951
|
-
},
|
|
988
|
+
}, mt = (e, t) => {
|
|
952
989
|
for (let n of e) {
|
|
953
990
|
if (n.eventType === "timer-fired") return !1;
|
|
954
991
|
if (n.eventType !== "timer-set") continue;
|
|
955
|
-
let e =
|
|
992
|
+
let e = J(n.payload?.scheduledWakeAt);
|
|
956
993
|
return e !== void 0 && e.getTime() > t;
|
|
957
994
|
}
|
|
958
995
|
return !1;
|
|
959
|
-
},
|
|
996
|
+
}, ht = (e, t) => {
|
|
960
997
|
if (e !== "suspended") return "no-progress";
|
|
961
998
|
for (let e of t) {
|
|
962
999
|
if (e.eventType === "signal-received" || e.eventType === "signal-sent") return "suspended";
|
|
963
1000
|
if (e.eventType === "signal-awaited") return "awaiting-signal";
|
|
964
1001
|
}
|
|
965
1002
|
return "suspended";
|
|
966
|
-
},
|
|
1003
|
+
}, gt = async (e, t = {}) => {
|
|
967
1004
|
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;
|
|
968
1005
|
try {
|
|
969
1006
|
d = await e.store.query({
|
|
@@ -986,24 +1023,24 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
986
1023
|
sawFullRunPage: !1,
|
|
987
1024
|
failures: [{
|
|
988
1025
|
subject: "_voltro_workflow_runs",
|
|
989
|
-
detail:
|
|
1026
|
+
detail: dt(e)
|
|
990
1027
|
}]
|
|
991
1028
|
};
|
|
992
1029
|
}
|
|
993
1030
|
for (let t of d) {
|
|
994
|
-
let i = t, o =
|
|
1031
|
+
let i = t, o = J(i.startedAt);
|
|
995
1032
|
if (typeof i.id != "string" || typeof i.tag != "string" || typeof i.executionId != "string" || typeof i.status != "string" || o === void 0) continue;
|
|
996
1033
|
let d, f;
|
|
997
1034
|
try {
|
|
998
|
-
d = await
|
|
1035
|
+
d = await ft(e.store, i.id, a), f = await pt(e.store, i.id);
|
|
999
1036
|
} catch (e) {
|
|
1000
1037
|
s.push({
|
|
1001
1038
|
subject: i.id,
|
|
1002
|
-
detail:
|
|
1039
|
+
detail: dt(e)
|
|
1003
1040
|
});
|
|
1004
1041
|
continue;
|
|
1005
1042
|
}
|
|
1006
|
-
if (
|
|
1043
|
+
if (mt(d, n)) {
|
|
1007
1044
|
u += 1;
|
|
1008
1045
|
continue;
|
|
1009
1046
|
}
|
|
@@ -1022,7 +1059,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1022
1059
|
status: i.status,
|
|
1023
1060
|
lastProgressAt: m,
|
|
1024
1061
|
idleMs: h,
|
|
1025
|
-
reason:
|
|
1062
|
+
reason: ht(i.status, d)
|
|
1026
1063
|
};
|
|
1027
1064
|
if (c.push(g), e.log?.warn("workflow.staleness: run has made no progress", {
|
|
1028
1065
|
workflow: g.tag,
|
|
@@ -1045,7 +1082,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1045
1082
|
} catch (e) {
|
|
1046
1083
|
s.push({
|
|
1047
1084
|
subject: g.runId,
|
|
1048
|
-
detail:
|
|
1085
|
+
detail: dt(e)
|
|
1049
1086
|
});
|
|
1050
1087
|
}
|
|
1051
1088
|
if (e.onStalled !== void 0) try {
|
|
@@ -1053,7 +1090,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1053
1090
|
} catch (e) {
|
|
1054
1091
|
s.push({
|
|
1055
1092
|
subject: `${g.runId}:onStalled`,
|
|
1056
|
-
detail:
|
|
1093
|
+
detail: dt(e)
|
|
1057
1094
|
});
|
|
1058
1095
|
}
|
|
1059
1096
|
}
|
|
@@ -1065,7 +1102,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1065
1102
|
sawFullRunPage: d.length >= i,
|
|
1066
1103
|
failures: s
|
|
1067
1104
|
};
|
|
1068
|
-
},
|
|
1105
|
+
}, _t = {
|
|
1069
1106
|
scanned: 0,
|
|
1070
1107
|
admitted: 0,
|
|
1071
1108
|
deferred: 0,
|
|
@@ -1074,16 +1111,17 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1074
1111
|
expired: 0,
|
|
1075
1112
|
evicted: 0,
|
|
1076
1113
|
failed: 0,
|
|
1114
|
+
deadLettered: 0,
|
|
1077
1115
|
timedOut: 0,
|
|
1078
1116
|
examined: !1
|
|
1079
|
-
},
|
|
1117
|
+
}, vt = 200, yt = async (e, t = {}) => {
|
|
1080
1118
|
let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, a, o, s;
|
|
1081
1119
|
try {
|
|
1082
|
-
a = await
|
|
1083
|
-
let t = await
|
|
1120
|
+
a = await ke(e.store);
|
|
1121
|
+
let t = await ze(e.store, n(), i);
|
|
1084
1122
|
o = t.due, s = t.nextDueAt;
|
|
1085
1123
|
} catch (e) {
|
|
1086
|
-
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }),
|
|
1124
|
+
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), _t;
|
|
1087
1125
|
}
|
|
1088
1126
|
let c = {
|
|
1089
1127
|
scanned: o.length,
|
|
@@ -1094,6 +1132,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1094
1132
|
expired: 0,
|
|
1095
1133
|
evicted: 0,
|
|
1096
1134
|
failed: 0,
|
|
1135
|
+
deadLettered: 0,
|
|
1097
1136
|
timedOut: 0
|
|
1098
1137
|
}, l = /* @__PURE__ */ new Map(), u = [];
|
|
1099
1138
|
for (let e of o) {
|
|
@@ -1105,32 +1144,86 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1105
1144
|
u.push(e);
|
|
1106
1145
|
}
|
|
1107
1146
|
for (let t of u) try {
|
|
1108
|
-
await
|
|
1147
|
+
await bt(e, t, a, c, n());
|
|
1109
1148
|
} catch (i) {
|
|
1110
|
-
c.failed++,
|
|
1149
|
+
if (c.failed++, e.isPermanentStartError?.(i) === !0) {
|
|
1150
|
+
let a = n(), o = String(i), s = `pending intent was dead-lettered after a permanent start failure: ${o}`;
|
|
1151
|
+
if (!await e.onAbandoned({
|
|
1152
|
+
workflowName: t.workflowName,
|
|
1153
|
+
payload: t.payload,
|
|
1154
|
+
callerContext: t.callerContext,
|
|
1155
|
+
reason: s,
|
|
1156
|
+
runId: null,
|
|
1157
|
+
executionId: null
|
|
1158
|
+
}).then(() => !0, (e) => (r?.warn?.("workflow flow control: permanent failure could not signal onFailure", {
|
|
1159
|
+
workflow: t.workflowName,
|
|
1160
|
+
intent: t.id,
|
|
1161
|
+
cause: String(e)
|
|
1162
|
+
}), !1))) {
|
|
1163
|
+
await W(e.store, t, o, a).catch(() => {});
|
|
1164
|
+
continue;
|
|
1165
|
+
}
|
|
1166
|
+
if (await He(e.store, t, o, a).catch(() => !1)) {
|
|
1167
|
+
c.deadLettered++, r?.warn?.("workflow flow control: intent dead-lettered", {
|
|
1168
|
+
workflow: t.workflowName,
|
|
1169
|
+
intent: t.id,
|
|
1170
|
+
cause: o
|
|
1171
|
+
});
|
|
1172
|
+
continue;
|
|
1173
|
+
}
|
|
1174
|
+
}
|
|
1175
|
+
r?.warn?.("workflow flow control: an intent failed to drain", {
|
|
1111
1176
|
workflow: t.workflowName,
|
|
1112
1177
|
intent: t.id,
|
|
1113
1178
|
cause: String(i)
|
|
1114
|
-
}), await
|
|
1179
|
+
}), await W(e.store, t, String(i), n()).catch(() => {});
|
|
1115
1180
|
}
|
|
1116
1181
|
for (let t of l.values()) try {
|
|
1117
|
-
await
|
|
1182
|
+
await St(e, t, a, c, n());
|
|
1118
1183
|
} catch (i) {
|
|
1119
1184
|
c.failed++;
|
|
1120
1185
|
let a = t[0];
|
|
1186
|
+
if (a !== void 0 && e.isPermanentStartError?.(i) === !0) {
|
|
1187
|
+
let o = n(), s = String(i), l = `pending batch was dead-lettered after a permanent start failure: ${s}`;
|
|
1188
|
+
if (!await e.onAbandoned({
|
|
1189
|
+
workflowName: a.workflowName,
|
|
1190
|
+
payload: { items: t.map((e) => e.payload) },
|
|
1191
|
+
callerContext: a.callerContext,
|
|
1192
|
+
reason: l,
|
|
1193
|
+
runId: null,
|
|
1194
|
+
executionId: null
|
|
1195
|
+
}).then(() => !0, (e) => (r?.warn?.("workflow flow control: permanent batch failure could not signal onFailure", {
|
|
1196
|
+
workflow: a.workflowName,
|
|
1197
|
+
intents: t.map((e) => e.id),
|
|
1198
|
+
size: t.length,
|
|
1199
|
+
cause: String(e)
|
|
1200
|
+
}), !1))) {
|
|
1201
|
+
await Promise.all(t.map((t) => W(e.store, t, s, o).catch(() => {})));
|
|
1202
|
+
continue;
|
|
1203
|
+
}
|
|
1204
|
+
if ((await Promise.all(t.map((t) => He(e.store, t, s, o).catch(() => !1)))).every(Boolean)) {
|
|
1205
|
+
c.deadLettered += t.length, r?.warn?.("workflow flow control: batch dead-lettered", {
|
|
1206
|
+
workflow: a.workflowName,
|
|
1207
|
+
intents: t.map((e) => e.id),
|
|
1208
|
+
size: t.length,
|
|
1209
|
+
cause: s
|
|
1210
|
+
});
|
|
1211
|
+
continue;
|
|
1212
|
+
}
|
|
1213
|
+
}
|
|
1121
1214
|
r?.warn?.("workflow flow control: a batch failed to drain", {
|
|
1122
1215
|
workflow: a?.workflowName,
|
|
1123
1216
|
size: t.length,
|
|
1124
1217
|
cause: String(i)
|
|
1125
|
-
}), a !== void 0 && await
|
|
1218
|
+
}), a !== void 0 && await W(e.store, a, String(i), n()).catch(() => {});
|
|
1126
1219
|
}
|
|
1127
|
-
return c.timedOut = await
|
|
1220
|
+
return c.timedOut = await wt(e, n()).catch(() => 0), {
|
|
1128
1221
|
...c,
|
|
1129
1222
|
examined: !0,
|
|
1130
1223
|
...s === void 0 ? {} : { nextDueAt: s }
|
|
1131
1224
|
};
|
|
1132
|
-
},
|
|
1133
|
-
if (t.mode === "delayed") return
|
|
1225
|
+
}, bt = async (e, t, n, r, i) => {
|
|
1226
|
+
if (t.mode === "delayed") return xt(e, t, n, r, i);
|
|
1134
1227
|
let a = e.controls.get(t.workflowName);
|
|
1135
1228
|
if (a === void 0) {
|
|
1136
1229
|
await e.onAbandoned({
|
|
@@ -1138,14 +1231,14 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1138
1231
|
payload: t.payload,
|
|
1139
1232
|
callerContext: t.callerContext,
|
|
1140
1233
|
reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this start was waiting in the admission queue`
|
|
1141
|
-
}), await
|
|
1234
|
+
}), await U(e.store, t.id), r.expired++;
|
|
1142
1235
|
return;
|
|
1143
1236
|
}
|
|
1144
|
-
if (
|
|
1145
|
-
await
|
|
1237
|
+
if (Se(a, t, i)) {
|
|
1238
|
+
await H({
|
|
1146
1239
|
store: e.store,
|
|
1147
1240
|
control: a,
|
|
1148
|
-
keys:
|
|
1241
|
+
keys: F(a, t.payload),
|
|
1149
1242
|
outcome: "expired",
|
|
1150
1243
|
mode: t.mode,
|
|
1151
1244
|
reason: `timeouts.start elapsed after ${i - t.firstSeenAt}ms`,
|
|
@@ -1160,14 +1253,14 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1160
1253
|
payload: t.payload,
|
|
1161
1254
|
callerContext: t.callerContext,
|
|
1162
1255
|
reason: `timeouts.start (${a.timeouts?.startMs}ms) elapsed while this start waited in the admission queue; ${t.collapsed} start(s) had collapsed into it`
|
|
1163
|
-
}), await
|
|
1256
|
+
}), await U(e.store, t.id), r.expired++;
|
|
1164
1257
|
return;
|
|
1165
1258
|
}
|
|
1166
|
-
let o =
|
|
1167
|
-
await
|
|
1259
|
+
let o = F(a, t.payload);
|
|
1260
|
+
await Ct(e, {
|
|
1168
1261
|
control: a,
|
|
1169
1262
|
intent: t,
|
|
1170
|
-
decision: await
|
|
1263
|
+
decision: await We({
|
|
1171
1264
|
store: e.store,
|
|
1172
1265
|
control: a,
|
|
1173
1266
|
keys: o,
|
|
@@ -1180,17 +1273,17 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1180
1273
|
now: i,
|
|
1181
1274
|
items: void 0
|
|
1182
1275
|
});
|
|
1183
|
-
},
|
|
1276
|
+
}, xt = async (e, t, n, r, i) => {
|
|
1184
1277
|
if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
|
|
1185
1278
|
await e.onAbandoned({
|
|
1186
1279
|
workflowName: t.workflowName,
|
|
1187
1280
|
payload: t.payload,
|
|
1188
1281
|
callerContext: t.callerContext,
|
|
1189
1282
|
reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this delayed start waited for its 'at' instant`
|
|
1190
|
-
}), await
|
|
1283
|
+
}), await U(e.store, t.id), r.expired++;
|
|
1191
1284
|
return;
|
|
1192
1285
|
}
|
|
1193
|
-
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await
|
|
1286
|
+
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await Ke({
|
|
1194
1287
|
store: e.store,
|
|
1195
1288
|
control: a,
|
|
1196
1289
|
payload: t.payload,
|
|
@@ -1201,15 +1294,15 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1201
1294
|
waiting: !1
|
|
1202
1295
|
});
|
|
1203
1296
|
if (o.kind === "queued") {
|
|
1204
|
-
await
|
|
1297
|
+
await U(e.store, t.id), r.deferred++;
|
|
1205
1298
|
return;
|
|
1206
1299
|
}
|
|
1207
1300
|
if (o.kind === "dropped") {
|
|
1208
|
-
await
|
|
1301
|
+
await U(e.store, t.id), r.dropped++;
|
|
1209
1302
|
return;
|
|
1210
1303
|
}
|
|
1211
1304
|
if (o.kind === "skipped") {
|
|
1212
|
-
await
|
|
1305
|
+
await U(e.store, t.id), r.skipped++;
|
|
1213
1306
|
return;
|
|
1214
1307
|
}
|
|
1215
1308
|
let s = await e.startAdmitted(a.workflowName, o.payload, t.callerContext);
|
|
@@ -1222,35 +1315,35 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1222
1315
|
source: "flow-control",
|
|
1223
1316
|
mode: "singleton"
|
|
1224
1317
|
}
|
|
1225
|
-
}).catch(() => !1), await
|
|
1226
|
-
for (let t of o.consume) await
|
|
1227
|
-
o.ledgerId !== void 0 && await
|
|
1228
|
-
},
|
|
1318
|
+
}).catch(() => !1), await Le(e.store, o.evict.executionId, i).catch(() => {}), r.evicted++);
|
|
1319
|
+
for (let t of o.consume) await U(e.store, t).catch(() => {});
|
|
1320
|
+
o.ledgerId !== void 0 && await Je(e.store, o.ledgerId, s.executionId, s.runId ?? null).catch(() => {}), await U(e.store, t.id), r.admitted++;
|
|
1321
|
+
}, St = async (e, t, n, r, i) => {
|
|
1229
1322
|
let a = t[0];
|
|
1230
1323
|
if (a === void 0) return;
|
|
1231
1324
|
let o = e.controls.get(a.workflowName);
|
|
1232
1325
|
if (o === void 0 || o.batch === void 0) {
|
|
1233
|
-
for (let n of t) await
|
|
1326
|
+
for (let n of t) await U(e.store, n.id);
|
|
1234
1327
|
r.expired += t.length;
|
|
1235
1328
|
return;
|
|
1236
1329
|
}
|
|
1237
1330
|
let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
|
|
1238
|
-
if (
|
|
1331
|
+
if (Se(o, c, i)) {
|
|
1239
1332
|
await e.onAbandoned({
|
|
1240
1333
|
workflowName: a.workflowName,
|
|
1241
1334
|
payload: { items: s.map((e) => e.payload) },
|
|
1242
1335
|
callerContext: c.callerContext,
|
|
1243
1336
|
reason: `timeouts.start elapsed with ${s.length} item(s) accumulated in the batch`
|
|
1244
1337
|
});
|
|
1245
|
-
for (let t of s) await
|
|
1338
|
+
for (let t of s) await U(e.store, t.id);
|
|
1246
1339
|
r.expired += s.length;
|
|
1247
1340
|
return;
|
|
1248
1341
|
}
|
|
1249
|
-
let l =
|
|
1250
|
-
await
|
|
1342
|
+
let l = F(o, c.payload);
|
|
1343
|
+
await Ct(e, {
|
|
1251
1344
|
control: o,
|
|
1252
1345
|
intent: c,
|
|
1253
|
-
decision: await
|
|
1346
|
+
decision: await We({
|
|
1254
1347
|
store: e.store,
|
|
1255
1348
|
control: o,
|
|
1256
1349
|
keys: l,
|
|
@@ -1263,10 +1356,10 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1263
1356
|
now: i,
|
|
1264
1357
|
items: s
|
|
1265
1358
|
});
|
|
1266
|
-
},
|
|
1359
|
+
}, Ct = async (e, t) => {
|
|
1267
1360
|
let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c } = t;
|
|
1268
1361
|
if (i.kind === "defer") {
|
|
1269
|
-
await
|
|
1362
|
+
await Pe({
|
|
1270
1363
|
store: e.store,
|
|
1271
1364
|
control: n,
|
|
1272
1365
|
decision: i,
|
|
@@ -1279,7 +1372,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1279
1372
|
return;
|
|
1280
1373
|
}
|
|
1281
1374
|
if (i.kind === "drop") {
|
|
1282
|
-
await
|
|
1375
|
+
await H({
|
|
1283
1376
|
store: e.store,
|
|
1284
1377
|
control: n,
|
|
1285
1378
|
keys: a,
|
|
@@ -1293,12 +1386,12 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1293
1386
|
tenantId: r.tenantId,
|
|
1294
1387
|
now: s
|
|
1295
1388
|
});
|
|
1296
|
-
for (let t of c ?? [r]) await
|
|
1389
|
+
for (let t of c ?? [r]) await U(e.store, t.id);
|
|
1297
1390
|
o.dropped++;
|
|
1298
1391
|
return;
|
|
1299
1392
|
}
|
|
1300
1393
|
if (i.kind === "skip") {
|
|
1301
|
-
await
|
|
1394
|
+
await H({
|
|
1302
1395
|
store: e.store,
|
|
1303
1396
|
control: n,
|
|
1304
1397
|
keys: a,
|
|
@@ -1312,7 +1405,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1312
1405
|
tenantId: r.tenantId,
|
|
1313
1406
|
now: s
|
|
1314
1407
|
});
|
|
1315
|
-
for (let t of c ?? [r]) await
|
|
1408
|
+
for (let t of c ?? [r]) await U(e.store, t.id);
|
|
1316
1409
|
o.skipped++;
|
|
1317
1410
|
return;
|
|
1318
1411
|
}
|
|
@@ -1325,7 +1418,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1325
1418
|
source: "flow-control",
|
|
1326
1419
|
mode: "singleton"
|
|
1327
1420
|
}
|
|
1328
|
-
}), await
|
|
1421
|
+
}), await Le(e.store, i.evict.executionId, s), await H({
|
|
1329
1422
|
store: e.store,
|
|
1330
1423
|
control: n,
|
|
1331
1424
|
keys: a,
|
|
@@ -1340,7 +1433,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1340
1433
|
now: s
|
|
1341
1434
|
}), o.evicted++);
|
|
1342
1435
|
let l = c === void 0 ? r.payload : { items: c.map((e) => e.payload) }, u = c === void 0 ? r.collapsed : c.reduce((e, t) => e + t.collapsed, 0), d = await e.startAdmitted(n.workflowName, l, r.callerContext);
|
|
1343
|
-
await
|
|
1436
|
+
await H({
|
|
1344
1437
|
store: e.store,
|
|
1345
1438
|
control: n,
|
|
1346
1439
|
keys: a,
|
|
@@ -1354,16 +1447,16 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1354
1447
|
tenantId: r.tenantId,
|
|
1355
1448
|
now: s
|
|
1356
1449
|
});
|
|
1357
|
-
for (let t of c ?? [r]) await
|
|
1450
|
+
for (let t of c ?? [r]) await U(e.store, t.id);
|
|
1358
1451
|
o.admitted++;
|
|
1359
|
-
},
|
|
1452
|
+
}, wt = async (e, t) => {
|
|
1360
1453
|
if (e.listRunningRuns === void 0) return 0;
|
|
1361
1454
|
let n = 0;
|
|
1362
1455
|
for (let r of e.controls.values()) {
|
|
1363
1456
|
if (r.timeouts?.finishMs === void 0) continue;
|
|
1364
1457
|
let i = await e.listRunningRuns(r.workflowName);
|
|
1365
1458
|
for (let a of i) {
|
|
1366
|
-
if (!
|
|
1459
|
+
if (!Ce(r, {
|
|
1367
1460
|
startedAt: a.startedAt,
|
|
1368
1461
|
terminal: !1
|
|
1369
1462
|
}, t)) continue;
|
|
@@ -1377,7 +1470,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1377
1470
|
source: "flow-control",
|
|
1378
1471
|
timeout: "finish"
|
|
1379
1472
|
}
|
|
1380
|
-
}) && (await
|
|
1473
|
+
}) && (await Le(e.store, a.executionId, t), await e.onAbandoned({
|
|
1381
1474
|
workflowName: a.workflowName,
|
|
1382
1475
|
payload: a.payload,
|
|
1383
1476
|
callerContext: null,
|
|
@@ -1388,33 +1481,33 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1388
1481
|
}
|
|
1389
1482
|
}
|
|
1390
1483
|
return n;
|
|
1391
|
-
},
|
|
1392
|
-
|
|
1393
|
-
},
|
|
1484
|
+
}, Tt = 3e5, Et, Dt = (e) => {
|
|
1485
|
+
Et = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
|
|
1486
|
+
}, Ot = () => {
|
|
1394
1487
|
let e = process.env.VOLTRO_WORKFLOW_SUSPEND_HINT_MS;
|
|
1395
1488
|
if (e !== void 0) {
|
|
1396
1489
|
let t = Number(e);
|
|
1397
1490
|
if (Number.isFinite(t) && t > 0) return t;
|
|
1398
1491
|
}
|
|
1399
|
-
return
|
|
1400
|
-
},
|
|
1401
|
-
|
|
1402
|
-
},
|
|
1403
|
-
let t =
|
|
1492
|
+
return Et ?? 3e5;
|
|
1493
|
+
}, kt = /* @__PURE__ */ new Set(), At = () => {
|
|
1494
|
+
kt.clear();
|
|
1495
|
+
}, jt = (e) => {
|
|
1496
|
+
let t = Ot();
|
|
1404
1497
|
if (!(e.timeoutMs > t)) return !1;
|
|
1405
1498
|
let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
|
|
1406
|
-
if (
|
|
1407
|
-
|
|
1499
|
+
if (kt.has(n)) return !1;
|
|
1500
|
+
kt.add(n);
|
|
1408
1501
|
let r = e.workflowName === void 0 ? "" : ` in workflow '${e.workflowName}'`;
|
|
1409
1502
|
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;
|
|
1410
|
-
},
|
|
1503
|
+
}, Mt = async (e, t) => {
|
|
1411
1504
|
if (e) try {
|
|
1412
1505
|
await e.recordEvent(t);
|
|
1413
1506
|
} catch {}
|
|
1414
|
-
},
|
|
1507
|
+
}, Nt = (e, t) => {
|
|
1415
1508
|
let r = m.gen(function* () {
|
|
1416
1509
|
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 864e5, s = yield* m.serviceOption(se), c;
|
|
1417
|
-
|
|
1510
|
+
jt({
|
|
1418
1511
|
workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
|
|
1419
1512
|
signalName: t.name,
|
|
1420
1513
|
timeoutMs: o,
|
|
@@ -1425,7 +1518,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1425
1518
|
let l = yield* a, u = yield* m.serviceOption(n), d = u._tag === "Some" ? u.value : void 0;
|
|
1426
1519
|
if (l === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
|
|
1427
1520
|
let f = l;
|
|
1428
|
-
yield* m.promise(() =>
|
|
1521
|
+
yield* m.promise(() => Mt(d, {
|
|
1429
1522
|
runId: f,
|
|
1430
1523
|
eventType: "signal-awaited",
|
|
1431
1524
|
payload: { signalName: t.name }
|
|
@@ -1450,7 +1543,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1450
1543
|
})).find((e) => e.payload?.signalName === t.name);
|
|
1451
1544
|
if (a !== void 0) {
|
|
1452
1545
|
let e = yield* y.decodeUnknown(t.schema)(a.payload?.value);
|
|
1453
|
-
return yield* m.promise(() =>
|
|
1546
|
+
return yield* m.promise(() => Mt(d, {
|
|
1454
1547
|
runId: f,
|
|
1455
1548
|
eventType: "signal-received",
|
|
1456
1549
|
payload: {
|
|
@@ -1467,16 +1560,16 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1467
1560
|
success: t.schema,
|
|
1468
1561
|
execute: r
|
|
1469
1562
|
});
|
|
1470
|
-
},
|
|
1563
|
+
}, Pt = async (e, t) => {
|
|
1471
1564
|
if (e !== void 0) try {
|
|
1472
1565
|
await e.recordEvent(t);
|
|
1473
1566
|
} catch {}
|
|
1474
|
-
},
|
|
1567
|
+
}, Ft = (e, t) => {
|
|
1475
1568
|
let r = m.gen(function* () {
|
|
1476
1569
|
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 864e5, s = t.take ?? 500, c = yield* a, l = yield* m.serviceOption(n), u = l._tag === "Some" ? l.value : void 0;
|
|
1477
1570
|
if (c === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
|
|
1478
|
-
let d = c, f = yield* t.since === "run-start" ?
|
|
1479
|
-
yield* m.promise(() =>
|
|
1571
|
+
let d = c, f = yield* t.since === "run-start" ? It(e, d) : m.succeed(/* @__PURE__ */ new Date());
|
|
1572
|
+
yield* m.promise(() => Pt(u, {
|
|
1480
1573
|
runId: d,
|
|
1481
1574
|
eventType: "event-awaited",
|
|
1482
1575
|
payload: {
|
|
@@ -1506,7 +1599,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1506
1599
|
g = a.length;
|
|
1507
1600
|
for (let e of a) {
|
|
1508
1601
|
let n = yield* y.decodeUnknown(t.schema)(e.payload);
|
|
1509
|
-
if (t.match(n)) return yield* m.promise(() =>
|
|
1602
|
+
if (t.match(n)) return yield* m.promise(() => Pt(u, {
|
|
1510
1603
|
runId: d,
|
|
1511
1604
|
eventType: "event-received",
|
|
1512
1605
|
payload: {
|
|
@@ -1523,7 +1616,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1523
1616
|
success: t.schema,
|
|
1524
1617
|
execute: r
|
|
1525
1618
|
});
|
|
1526
|
-
},
|
|
1619
|
+
}, It = (e, t) => m.gen(function* () {
|
|
1527
1620
|
let n = (yield* m.tryPromise({
|
|
1528
1621
|
try: () => e.store.query({
|
|
1529
1622
|
table: "_voltro_workflow_runs",
|
|
@@ -1541,10 +1634,10 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1541
1634
|
if (!Number.isNaN(e.getTime())) return e;
|
|
1542
1635
|
}
|
|
1543
1636
|
return /* @__PURE__ */ new Date(0);
|
|
1544
|
-
}),
|
|
1637
|
+
}), Lt = (e) => new Promise((t) => setTimeout(t, e)), Rt = () => {
|
|
1545
1638
|
let e = globalThis.crypto;
|
|
1546
1639
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
1547
|
-
},
|
|
1640
|
+
}, zt = () => `wfu_${Rt()}`, Y = async (e, t) => {
|
|
1548
1641
|
let n = t.id ?? t.executionId;
|
|
1549
1642
|
if (!n) throw Error("workflow message target requires target.id or target.executionId");
|
|
1550
1643
|
let r = await e.query({
|
|
@@ -1566,8 +1659,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1566
1659
|
}))[0];
|
|
1567
1660
|
if (!i) throw Error(`workflow message target not found: ${n}`);
|
|
1568
1661
|
return i;
|
|
1569
|
-
},
|
|
1570
|
-
let t = await
|
|
1662
|
+
}, Bt = async (e) => {
|
|
1663
|
+
let t = await Y(e.store, e.target);
|
|
1571
1664
|
return { eventId: (await e.recorder.recordEvent({
|
|
1572
1665
|
runId: t.id,
|
|
1573
1666
|
eventType: "signal-sent",
|
|
@@ -1576,8 +1669,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1576
1669
|
value: e.payload
|
|
1577
1670
|
}
|
|
1578
1671
|
})).id };
|
|
1579
|
-
},
|
|
1580
|
-
let t = await
|
|
1672
|
+
}, Vt = async (e) => {
|
|
1673
|
+
let t = await Y(e.store, e.target), n = zt(), r = await e.recorder.recordEvent({
|
|
1581
1674
|
runId: t.id,
|
|
1582
1675
|
eventType: "update-requested",
|
|
1583
1676
|
payload: {
|
|
@@ -1614,15 +1707,15 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1614
1707
|
}), t;
|
|
1615
1708
|
}
|
|
1616
1709
|
if (Date.now() - i >= a) throw Error(`Timed out waiting for workflow update '${e.updateName}' (${n})`);
|
|
1617
|
-
await
|
|
1710
|
+
await Lt(o);
|
|
1618
1711
|
}
|
|
1619
|
-
},
|
|
1712
|
+
}, Ht = 864e5, Ut = "voltro/suspending-signal", Wt = (e, t) => `${Ut}/${e}/${t}`, Gt = (e) => u.make(e, { success: y.Unknown }), Kt = async (e, t) => {
|
|
1620
1713
|
if (e) try {
|
|
1621
1714
|
await e.recordEvent(t);
|
|
1622
1715
|
} catch {}
|
|
1623
|
-
},
|
|
1624
|
-
let e = t.timeoutMs ??
|
|
1625
|
-
i !== void 0 && (yield* m.promise(() =>
|
|
1716
|
+
}, qt = (e, t) => m.gen(function* () {
|
|
1717
|
+
let e = t.timeoutMs ?? Ht, r = Gt(Wt((yield* f.WorkflowInstance).workflow.name, t.name)), i = yield* a, o = yield* m.serviceOption(n), s = o._tag === "Some" ? o.value : void 0;
|
|
1718
|
+
i !== void 0 && (yield* m.promise(() => Kt(s, {
|
|
1626
1719
|
runId: i,
|
|
1627
1720
|
eventType: "signal-awaited",
|
|
1628
1721
|
payload: { signalName: t.name }
|
|
@@ -1631,7 +1724,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1631
1724
|
name: `await-signal-timeout/${t.name}`,
|
|
1632
1725
|
duration: `${e} millis`
|
|
1633
1726
|
}).pipe(m.andThen(m.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${t.name}') timed out after ${e}ms`))))) : yield* c, p = yield* y.decodeUnknown(t.schema)(d);
|
|
1634
|
-
return i !== void 0 && (yield* m.promise(() =>
|
|
1727
|
+
return i !== void 0 && (yield* m.promise(() => Kt(s, {
|
|
1635
1728
|
runId: i,
|
|
1636
1729
|
eventType: "signal-received",
|
|
1637
1730
|
payload: {
|
|
@@ -1639,19 +1732,19 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1639
1732
|
value: p
|
|
1640
1733
|
}
|
|
1641
1734
|
}))), p;
|
|
1642
|
-
}),
|
|
1735
|
+
}), Jt = (e) => m.gen(function* () {
|
|
1643
1736
|
let t = e.target.executionId, n = e.target.workflowName;
|
|
1644
1737
|
if (t === void 0 || n === void 0) {
|
|
1645
1738
|
let r = e.store;
|
|
1646
1739
|
if (r === void 0) return yield* m.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
|
|
1647
1740
|
let i = yield* m.tryPromise({
|
|
1648
|
-
try: () =>
|
|
1741
|
+
try: () => Y(r, e.target),
|
|
1649
1742
|
catch: (e) => e
|
|
1650
1743
|
});
|
|
1651
1744
|
t ??= i.executionId, n ??= i.tag;
|
|
1652
1745
|
}
|
|
1653
1746
|
if (t === void 0 || n === void 0) return { completed: !1 };
|
|
1654
|
-
let r =
|
|
1747
|
+
let r = Wt(n, e.signalName), i = Gt(r), a = new u.TokenParsed({
|
|
1655
1748
|
workflowName: n,
|
|
1656
1749
|
executionId: t,
|
|
1657
1750
|
deferredName: r
|
|
@@ -1660,11 +1753,11 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1660
1753
|
token: a,
|
|
1661
1754
|
exit: g.succeed(e.payload)
|
|
1662
1755
|
}), { completed: !0 };
|
|
1663
|
-
}), X = "_voltro_budget_holds",
|
|
1756
|
+
}), X = "_voltro_budget_holds", Yt = "budget-hold", Xt = (e) => `${Yt}:${e}`, Zt = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, Qt = async (e, t) => (await e.query({
|
|
1664
1757
|
table: X,
|
|
1665
1758
|
predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
|
|
1666
1759
|
order: []
|
|
1667
|
-
})).length,
|
|
1760
|
+
})).length, $t = j(X, {
|
|
1668
1761
|
id: w({ prefix: "bhd" }),
|
|
1669
1762
|
holdKey: M().maxLength(191),
|
|
1670
1763
|
budget: M(),
|
|
@@ -1678,33 +1771,33 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1678
1771
|
heldAt: N().default("now"),
|
|
1679
1772
|
releasedAt: N().nullable(),
|
|
1680
1773
|
outcome: M().nullable()
|
|
1681
|
-
}).index(["budget", "releasedAt"]),
|
|
1774
|
+
}).index(["budget", "releasedAt"]), en = () => {
|
|
1682
1775
|
ie({
|
|
1683
1776
|
source: "framework",
|
|
1684
1777
|
table: X,
|
|
1685
1778
|
timeColumn: "releasedAt",
|
|
1686
1779
|
ttlMs: ae(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
|
|
1687
1780
|
});
|
|
1688
|
-
},
|
|
1781
|
+
}, tn = class extends Error {
|
|
1689
1782
|
budget;
|
|
1690
1783
|
holdKey;
|
|
1691
1784
|
constructor(e, t, n) {
|
|
1692
1785
|
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;
|
|
1693
1786
|
}
|
|
1694
|
-
},
|
|
1695
|
-
|
|
1787
|
+
}, nn = 6048e5, rn = (e) => m.gen(function* () {
|
|
1788
|
+
en();
|
|
1696
1789
|
let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
|
|
1697
1790
|
executionId: e.executionId,
|
|
1698
1791
|
stepName: e.stepName,
|
|
1699
1792
|
budget: e.budget
|
|
1700
1793
|
};
|
|
1701
1794
|
for (;;) {
|
|
1702
|
-
let i = yield* m.promise(() =>
|
|
1795
|
+
let i = yield* m.promise(() => on(e.store, r)), a = i.length, o = i.length === 0 ? Date.now() : an(i[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = Zt({
|
|
1703
1796
|
...r,
|
|
1704
1797
|
generation: a
|
|
1705
1798
|
});
|
|
1706
|
-
if (s <= 0) return yield* m.promise(() =>
|
|
1707
|
-
let l =
|
|
1799
|
+
if (s <= 0) return yield* m.promise(() => sn(e.store, r, "expired")), yield* m.fail(new tn(e.budget, c, t));
|
|
1800
|
+
let l = Xt(c);
|
|
1708
1801
|
yield* m.promise(() => e.store.insertIgnore(X, {
|
|
1709
1802
|
id: S({
|
|
1710
1803
|
kind: "typeid",
|
|
@@ -1724,7 +1817,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1724
1817
|
outcome: null
|
|
1725
1818
|
}, { conflictColumns: ["holdKey"] }));
|
|
1726
1819
|
let u = Math.min(n, s);
|
|
1727
|
-
if (yield*
|
|
1820
|
+
if (yield* qt({ store: e.store }, {
|
|
1728
1821
|
name: l,
|
|
1729
1822
|
schema: y.Unknown,
|
|
1730
1823
|
timeoutMs: u
|
|
@@ -1733,16 +1826,16 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1733
1826
|
outcome: "recheck"
|
|
1734
1827
|
}, { where: b(x("holdKey", c), E("releasedAt")) })), yield* e.hasHeadroom) return;
|
|
1735
1828
|
}
|
|
1736
|
-
}),
|
|
1829
|
+
}), an = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), on = async (e, t) => [...await e.query({
|
|
1737
1830
|
table: X,
|
|
1738
1831
|
predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
|
|
1739
1832
|
order: []
|
|
1740
|
-
})].sort((e, t) => String(e.id).localeCompare(String(t.id))),
|
|
1833
|
+
})].sort((e, t) => String(e.id).localeCompare(String(t.id))), sn = async (e, t, n) => {
|
|
1741
1834
|
await e.updateMany(X, {
|
|
1742
1835
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
1743
1836
|
outcome: n
|
|
1744
1837
|
}, { where: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget), E("releasedAt")) });
|
|
1745
|
-
},
|
|
1838
|
+
}, cn = (e) => m.gen(function* () {
|
|
1746
1839
|
let t = e.tenantId === void 0 ? b(x("budget", e.budget), E("releasedAt")) : b(x("budget", e.budget), x("tenantId", e.tenantId), E("releasedAt")), n = yield* m.promise(() => e.store.query({
|
|
1747
1840
|
table: X,
|
|
1748
1841
|
predicate: t,
|
|
@@ -1751,7 +1844,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1751
1844
|
for (let t of n) (yield* m.promise(() => e.store.updateMany("_voltro_budget_holds", {
|
|
1752
1845
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
1753
1846
|
outcome: e.outcome ?? "released"
|
|
1754
|
-
}, { where: b(x("id", String(t.id)), E("releasedAt")) }))) === 1 && (yield*
|
|
1847
|
+
}, { where: b(x("id", String(t.id)), E("releasedAt")) }))) === 1 && (yield* Jt({
|
|
1755
1848
|
target: {
|
|
1756
1849
|
executionId: String(t.executionId),
|
|
1757
1850
|
workflowName: String(t.workflowName)
|
|
@@ -1763,7 +1856,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1763
1856
|
}
|
|
1764
1857
|
}).pipe(m.catchAll(() => m.succeed({ completed: !1 }))), r += 1);
|
|
1765
1858
|
return { released: r };
|
|
1766
|
-
}),
|
|
1859
|
+
}), ln = async (e, t) => {
|
|
1767
1860
|
let n = t?.budget === void 0 ? E("releasedAt") : b(x("budget", t.budget), E("releasedAt"));
|
|
1768
1861
|
return (await e.query({
|
|
1769
1862
|
table: X,
|
|
@@ -1779,8 +1872,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1779
1872
|
stepName: String(e.stepName),
|
|
1780
1873
|
heldAt: e.heldAt instanceof Date ? e.heldAt.toISOString() : String(e.heldAt ?? "")
|
|
1781
1874
|
}));
|
|
1782
|
-
},
|
|
1783
|
-
let t = await
|
|
1875
|
+
}, un = async (e) => {
|
|
1876
|
+
let t = await ln(e), n = /* @__PURE__ */ new Map();
|
|
1784
1877
|
for (let e of t) {
|
|
1785
1878
|
let t = `${e.budget}\u0000${e.tenantId ?? ""}`;
|
|
1786
1879
|
n.has(t) || n.set(t, {
|
|
@@ -1789,17 +1882,17 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1789
1882
|
});
|
|
1790
1883
|
}
|
|
1791
1884
|
return [...n.values()];
|
|
1792
|
-
},
|
|
1885
|
+
}, dn = async (e, t) => {
|
|
1793
1886
|
if (e) try {
|
|
1794
1887
|
await e.recordEvent(t);
|
|
1795
1888
|
} catch {}
|
|
1796
|
-
},
|
|
1889
|
+
}, fn = (e) => {
|
|
1797
1890
|
let t = p.failureOption(e), n = Array.from(p.defects(e)), r = t._tag === "Some" ? t.value : n[0] ?? p.squash(e);
|
|
1798
1891
|
return {
|
|
1799
1892
|
errorTag: r && typeof r == "object" && "_tag" in r ? String(r._tag) : null,
|
|
1800
1893
|
errorMessage: r?.message ?? String(r)
|
|
1801
1894
|
};
|
|
1802
|
-
},
|
|
1895
|
+
}, pn = (e, t) => {
|
|
1803
1896
|
let r = m.gen(function* () {
|
|
1804
1897
|
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 3e4, s = yield* a, c = yield* m.serviceOption(n), l = c._tag === "Some" ? c.value : void 0;
|
|
1805
1898
|
if (s === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
|
|
@@ -1823,7 +1916,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1823
1916
|
}), s = new Set(a.filter((e) => e.eventType === "update-completed" || e.eventType === "update-failed").map((e) => e.payload?.updateId).filter((e) => typeof e == "string" && e.length > 0)), c = a.find((e) => e.eventType === "update-requested" && e.payload?.updateName === t.name && typeof e.payload.updateId == "string" && !s.has(e.payload.updateId));
|
|
1824
1917
|
if (c !== void 0) {
|
|
1825
1918
|
let e = c.payload.updateId;
|
|
1826
|
-
yield* m.promise(() =>
|
|
1919
|
+
yield* m.promise(() => dn(l, {
|
|
1827
1920
|
runId: u,
|
|
1828
1921
|
eventType: "update-received",
|
|
1829
1922
|
payload: {
|
|
@@ -1831,24 +1924,24 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1831
1924
|
updateName: t.name
|
|
1832
1925
|
}
|
|
1833
1926
|
}));
|
|
1834
|
-
let n = yield* y.decodeUnknown(t.schema)(c.payload?.value).pipe(m.tapErrorCause((n) => m.promise(() =>
|
|
1927
|
+
let n = yield* y.decodeUnknown(t.schema)(c.payload?.value).pipe(m.tapErrorCause((n) => m.promise(() => dn(l, {
|
|
1835
1928
|
runId: u,
|
|
1836
1929
|
eventType: "update-failed",
|
|
1837
1930
|
payload: {
|
|
1838
1931
|
updateId: e,
|
|
1839
1932
|
updateName: t.name,
|
|
1840
|
-
...
|
|
1933
|
+
...fn(n)
|
|
1841
1934
|
}
|
|
1842
|
-
})))), r = yield* (t.handle ? t.handle(n) : m.succeed(n)).pipe(m.flatMap((e) => t.success ? y.decodeUnknown(t.success)(e) : m.succeed(e))).pipe(m.tapErrorCause((n) => m.promise(() =>
|
|
1935
|
+
})))), r = yield* (t.handle ? t.handle(n) : m.succeed(n)).pipe(m.flatMap((e) => t.success ? y.decodeUnknown(t.success)(e) : m.succeed(e))).pipe(m.tapErrorCause((n) => m.promise(() => dn(l, {
|
|
1843
1936
|
runId: u,
|
|
1844
1937
|
eventType: "update-failed",
|
|
1845
1938
|
payload: {
|
|
1846
1939
|
updateId: e,
|
|
1847
1940
|
updateName: t.name,
|
|
1848
|
-
...
|
|
1941
|
+
...fn(n)
|
|
1849
1942
|
}
|
|
1850
1943
|
}))));
|
|
1851
|
-
return yield* m.promise(() =>
|
|
1944
|
+
return yield* m.promise(() => dn(l, {
|
|
1852
1945
|
runId: u,
|
|
1853
1946
|
eventType: "update-completed",
|
|
1854
1947
|
payload: {
|
|
@@ -1866,7 +1959,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1866
1959
|
success: t.success ?? t.schema,
|
|
1867
1960
|
execute: r
|
|
1868
1961
|
});
|
|
1869
|
-
},
|
|
1962
|
+
}, mn = 8192, hn = 3, gn = 2e3, _n = () => {
|
|
1870
1963
|
let e = (e) => {
|
|
1871
1964
|
if (e === void 0) return;
|
|
1872
1965
|
let t = Number(e);
|
|
@@ -1876,7 +1969,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1876
1969
|
...t === void 0 ? {} : { maxRunReclaims: t },
|
|
1877
1970
|
...n === void 0 ? {} : { replayShapeLimit: n }
|
|
1878
1971
|
};
|
|
1879
|
-
},
|
|
1972
|
+
}, vn = (e) => {
|
|
1880
1973
|
let t = typeof e == "string" ? (() => {
|
|
1881
1974
|
try {
|
|
1882
1975
|
return JSON.parse(e);
|
|
@@ -1885,10 +1978,10 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1885
1978
|
}
|
|
1886
1979
|
})() : e;
|
|
1887
1980
|
if (Array.isArray(t)) return t.filter((e) => typeof e == "string");
|
|
1888
|
-
},
|
|
1981
|
+
}, yn = () => {
|
|
1889
1982
|
let e = globalThis.crypto;
|
|
1890
1983
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
1891
|
-
},
|
|
1984
|
+
}, bn = (e) => `${e}_${yn()}`, Z = (e, t = mn) => {
|
|
1892
1985
|
if (e == null) return e;
|
|
1893
1986
|
try {
|
|
1894
1987
|
let n = JSON.stringify(e);
|
|
@@ -1904,8 +1997,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
1904
1997
|
let t = {};
|
|
1905
1998
|
for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
|
|
1906
1999
|
return t;
|
|
1907
|
-
},
|
|
1908
|
-
let t = e.truncateBytes ??
|
|
2000
|
+
}, xn = (e) => {
|
|
2001
|
+
let t = e.truncateBytes ?? mn, n = e.makeId ?? bn, r = (t, n) => e.log?.warn(t, n), i = e.encryptStepPayload ?? ((e) => e), a = e.emit, o = e.recording === "coarse";
|
|
1909
2002
|
return {
|
|
1910
2003
|
startStep: async ({ runId: s, stepName: c, attempt: l, stepInput: u, retryPolicy: d }) => {
|
|
1911
2004
|
if (!o) try {
|
|
@@ -2008,7 +2101,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2008
2101
|
return { id: l };
|
|
2009
2102
|
}
|
|
2010
2103
|
};
|
|
2011
|
-
},
|
|
2104
|
+
}, Sn = (e, t, n) => m.gen(function* () {
|
|
2012
2105
|
let r = e.store.query;
|
|
2013
2106
|
if (r === void 0) return;
|
|
2014
2107
|
let i = e.replayShapeLimit ?? 2e3, a = yield* m.promise(() => r({
|
|
@@ -2038,8 +2131,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2038
2131
|
return typeof t == "string" ? [{ stepName: t }] : [];
|
|
2039
2132
|
});
|
|
2040
2133
|
return s.length === 0 ? void 0 : o(s);
|
|
2041
|
-
}),
|
|
2042
|
-
let l = o.truncateBytes ??
|
|
2134
|
+
}), Cn = (o, c) => {
|
|
2135
|
+
let l = o.truncateBytes ?? mn, u = o.makeId ?? bn, f = o.recorder ?? xn(o), h = (e, t) => o.log?.warn(e, t), v = o.emit, y = (e, t, n) => m.promise(async () => {
|
|
2043
2136
|
if (o.onParentClose) try {
|
|
2044
2137
|
await o.onParentClose({
|
|
2045
2138
|
workflowName: o.name,
|
|
@@ -2115,9 +2208,9 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2115
2208
|
durationMs: 0
|
|
2116
2209
|
})), yield* m.fail(Error(e));
|
|
2117
2210
|
}
|
|
2118
|
-
let
|
|
2211
|
+
let re = o.workflowPatches ?? [], k;
|
|
2119
2212
|
if (D?.id !== void 0) {
|
|
2120
|
-
T = D.id,
|
|
2213
|
+
T = D.id, re = vn(D.workflowPatches) ?? re;
|
|
2121
2214
|
let e = D.runnerEnteredAt !== null && D.runnerEnteredAt !== void 0, t = typeof D.reclaimCount == "number" ? D.reclaimCount : Number(D.reclaimCount ?? 0), n = e ? (Number.isFinite(t) ? t : 0) + 1 : 0, r = o.maxRunReclaims ?? 3;
|
|
2122
2215
|
if (e && n >= r) {
|
|
2123
2216
|
let e = `Workflow '${o.name}' run '${S}' killed its runner ${n} times in a row; parked instead of reclaimed again (maxRunReclaims=${r}).`;
|
|
@@ -2152,7 +2245,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2152
2245
|
let t = yield* se;
|
|
2153
2246
|
return yield* d.suspend(t);
|
|
2154
2247
|
}
|
|
2155
|
-
|
|
2248
|
+
k = yield* Sn(o, T, h), yield* E("failed to record workflow re-entry", m.gen(function* () {
|
|
2156
2249
|
let t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2157
2250
|
status: "running",
|
|
2158
2251
|
errorTag: null,
|
|
@@ -2218,7 +2311,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2218
2311
|
}));
|
|
2219
2312
|
}
|
|
2220
2313
|
}));
|
|
2221
|
-
let
|
|
2314
|
+
let A = o.subject?.tenantId, ie = c(ee, S).pipe(m.locally(a, T), m.locally(r, S), m.locally(t, typeof A == "string" ? A : void 0), m.locally(i, re), m.locally(s, k), m.provideService(n, f)), ae = o.pluginWorkflowStepLayer ? ie.pipe(m.provide(o.pluginWorkflowStepLayer)) : ie, j = yield* d.intoResult(ae);
|
|
2222
2315
|
if (d.isResult(j) && j._tag === "Suspended") {
|
|
2223
2316
|
let e = j.cause, t = e !== void 0 && !p.isEmpty(e), n = t ? p.squash(e) : void 0, r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = t ? n?.message ?? String(n) : null;
|
|
2224
2317
|
t && (yield* m.sync(() => ce({
|
|
@@ -2258,8 +2351,8 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2258
2351
|
return yield* d.suspend(a);
|
|
2259
2352
|
}
|
|
2260
2353
|
let M = j;
|
|
2261
|
-
if (
|
|
2262
|
-
let t =
|
|
2354
|
+
if (k !== void 0 && T !== void 0) {
|
|
2355
|
+
let t = k.settle();
|
|
2263
2356
|
if (t.length > 0) {
|
|
2264
2357
|
let n = T;
|
|
2265
2358
|
h("workflow replay reached a different step shape than this run recorded", {
|
|
@@ -2339,7 +2432,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2339
2432
|
completedAtSec: Date.now() / 1e3
|
|
2340
2433
|
})), N;
|
|
2341
2434
|
});
|
|
2342
|
-
},
|
|
2435
|
+
}, wn = (e) => e === "cancel" || e === "terminate", Tn = (e) => e === "running" || e === "suspended", En = async (e) => {
|
|
2343
2436
|
let t = await e.store.query({
|
|
2344
2437
|
table: "_voltro_workflow_runs",
|
|
2345
2438
|
order: [{
|
|
@@ -2365,7 +2458,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2365
2458
|
});
|
|
2366
2459
|
continue;
|
|
2367
2460
|
}
|
|
2368
|
-
if (!
|
|
2461
|
+
if (!wn(r.parentClosePolicy)) {
|
|
2369
2462
|
n.push({
|
|
2370
2463
|
...t,
|
|
2371
2464
|
action: "skipped",
|
|
@@ -2373,7 +2466,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2373
2466
|
});
|
|
2374
2467
|
continue;
|
|
2375
2468
|
}
|
|
2376
|
-
if (!
|
|
2469
|
+
if (!Tn(r.status)) {
|
|
2377
2470
|
n.push({
|
|
2378
2471
|
...t,
|
|
2379
2472
|
action: "skipped",
|
|
@@ -2421,7 +2514,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2421
2514
|
}
|
|
2422
2515
|
}
|
|
2423
2516
|
return n;
|
|
2424
|
-
},
|
|
2517
|
+
}, Dn = (e) => {
|
|
2425
2518
|
if (e == null) return null;
|
|
2426
2519
|
if (e instanceof Date) return e;
|
|
2427
2520
|
if (typeof e == "string" || typeof e == "number") {
|
|
@@ -2429,7 +2522,7 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2429
2522
|
return Number.isNaN(t.getTime()) ? null : t;
|
|
2430
2523
|
}
|
|
2431
2524
|
return null;
|
|
2432
|
-
},
|
|
2525
|
+
}, On = (e) => typeof e == "number" ? e : e == null ? null : Number(e), $ = (e) => e == null ? null : String(e), kn = (e) => {
|
|
2433
2526
|
let t = /* @__PURE__ */ new Map();
|
|
2434
2527
|
for (let n of e) {
|
|
2435
2528
|
let e = String(n.stepName), r = t.get(e);
|
|
@@ -2437,27 +2530,27 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2437
2530
|
}
|
|
2438
2531
|
let n = [];
|
|
2439
2532
|
for (let [e, r] of t) {
|
|
2440
|
-
r.sort((e, t) => (
|
|
2533
|
+
r.sort((e, t) => (On(e.attempt) ?? 0) - (On(t.attempt) ?? 0));
|
|
2441
2534
|
let t = r[r.length - 1], i = $(t.errorTag), a = $(t.errorMessage), o = i !== null || a !== null ? {
|
|
2442
2535
|
tag: i,
|
|
2443
2536
|
message: a ?? ""
|
|
2444
2537
|
} : null;
|
|
2445
2538
|
n.push({
|
|
2446
2539
|
name: e,
|
|
2447
|
-
attempt:
|
|
2540
|
+
attempt: On(t.attempt) ?? r.length,
|
|
2448
2541
|
attempts: r.length,
|
|
2449
2542
|
status: t.status ?? "running",
|
|
2450
2543
|
input: t.input ?? null,
|
|
2451
2544
|
output: t.output ?? null,
|
|
2452
2545
|
error: o,
|
|
2453
|
-
durationMs:
|
|
2546
|
+
durationMs: On(t.durationMs)
|
|
2454
2547
|
});
|
|
2455
2548
|
}
|
|
2456
2549
|
return n.sort((t, n) => {
|
|
2457
2550
|
let r = e.find((e) => String(e.stepName) === t.name), i = e.find((e) => String(e.stepName) === n.name);
|
|
2458
|
-
return (
|
|
2551
|
+
return (Dn(r?.startedAt)?.getTime() ?? 0) - (Dn(i?.startedAt)?.getTime() ?? 0);
|
|
2459
2552
|
}), n;
|
|
2460
|
-
},
|
|
2553
|
+
}, An = (e) => {
|
|
2461
2554
|
if (e == null) return null;
|
|
2462
2555
|
if (typeof e == "string") try {
|
|
2463
2556
|
return JSON.parse(e);
|
|
@@ -2465,10 +2558,10 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2465
2558
|
return null;
|
|
2466
2559
|
}
|
|
2467
2560
|
return typeof e == "object" ? e : null;
|
|
2468
|
-
},
|
|
2469
|
-
let n =
|
|
2561
|
+
}, jn = async (e, t) => {
|
|
2562
|
+
let n = k(ue), r = (await t.query(n.where(re(x("id", e), x("executionId", e))).limit(1).descriptor))[0];
|
|
2470
2563
|
if (r === void 0) return null;
|
|
2471
|
-
let i = String(r.id), a =
|
|
2564
|
+
let i = String(r.id), a = k(de), o = await t.query(a.where(x("runId", i)).descriptor);
|
|
2472
2565
|
return {
|
|
2473
2566
|
id: i,
|
|
2474
2567
|
executionId: $(r.executionId) ?? "",
|
|
@@ -2476,16 +2569,16 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2476
2569
|
status: r.status ?? "running",
|
|
2477
2570
|
input: r.payload ?? null,
|
|
2478
2571
|
output: r.output ?? null,
|
|
2479
|
-
subject:
|
|
2572
|
+
subject: An(r.subject),
|
|
2480
2573
|
source: $(r.source),
|
|
2481
|
-
steps:
|
|
2482
|
-
startedAt:
|
|
2483
|
-
finishedAt:
|
|
2574
|
+
steps: kn(o),
|
|
2575
|
+
startedAt: Dn(r.startedAt) ?? /* @__PURE__ */ new Date(0),
|
|
2576
|
+
finishedAt: Dn(r.completedAt),
|
|
2484
2577
|
traceId: $(r.traceId),
|
|
2485
2578
|
parentExecutionId: $(r.parentExecutionId),
|
|
2486
2579
|
parentClosePolicy: $(r.parentClosePolicy)
|
|
2487
2580
|
};
|
|
2488
|
-
},
|
|
2581
|
+
}, Mn = () => {
|
|
2489
2582
|
let e = [], t = [], r = 0, i = 0;
|
|
2490
2583
|
return {
|
|
2491
2584
|
layer: v.succeed(n, {
|
|
@@ -2534,4 +2627,4 @@ var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
|
2534
2627
|
};
|
|
2535
2628
|
};
|
|
2536
2629
|
//#endregion
|
|
2537
|
-
export {
|
|
2630
|
+
export { Ze as $, Vt as A, Se as At, ct as B, ue as Bt, rn as C, Le as Ct, zt as D, we as Dt, Wt as E, _e as Et, At as F, ge as Ft, tt as G, lt as H, Ot as I, me as It, $e as J, nt as K, Dt as L, pe as Lt, Nt as M, ve as Mt, Tt as N, F as Nt, Y as O, be as Ot, jt as P, he as Pt, Qe as Q, vt as R, fe as Rt, cn as S, H as St, Jt as T, Ue as Tt, gt as U, ut as V, le as Vt, G as W, st as X, rt as Y, it as Z, Qt as _, ze as _t, gn as a, Te as at, un as b, Me as bt, _n as c, He as ct, Cn as d, Re as dt, Ye as et, pn as f, We as ft, $t as g, De as gt, nn as h, Ae as ht, hn as i, Ee as it, Ft as j, ye as jt, Bt as k, Ce as kt, Q as l, U as lt, tn as m, Fe as mt, jn as n, Je as nt, xn as o, L as ot, X as p, W as pt, et as q, En as r, R as rt, vn as s, Be as st, Mn as t, Ke as tt, Z as u, Ve as ut, Zt as v, Pe as vt, qt as w, je as wt, ln as x, ke as xt, Xt as y, Ge as yt, yt as z, de as zt };
|