@voltro/workflow 0.85.0 → 0.86.0

package/dist/workflowRestartObservation.js

@@ -0,0 +1,60 @@
+import "./workflowDelivery.js";
+import { activityPrimaryKey as e, classifyRunReply as t, runEntityAddress as n } from "./workflowJournal.js";
+import { Effect as r, Option as i, Schema as a } from "effect";
+import { SqlClient as o } from "effect/sql";
+import { MessageStorage as s, Sharding as c } from "effect/cluster";
+//#region src/workflowRestartObservation.ts
+var l = a.fromJsonString(a.Record(a.String, a.String)), u = (u) => r.gen(function* () {
+	if (!/^[1-9]\d*$/.test(u.delivery.requestId) || u.executionId.length === 0 || u.activities.some((e) => e.name.length === 0 || !Number.isSafeInteger(e.attempt) || e.attempt < 1)) return yield* r.die(/* @__PURE__ */ Error("Restart observation requires an exact delivery and valid activity attempts"));
+	let d = (yield* o.SqlClient).withoutTransforms(), f = yield* s.MessageStorage, p = yield* c.Sharding, m = n(u.workflow, u.executionId, p), h = (e, t) => r.gen(function* () {
+		let [n] = yield* d`SELECT m.entity_type, m.entity_id, m.tag, m.headers, r.id AS reply_id, r.payload
+       FROM cluster_messages m
+       LEFT JOIN cluster_replies r ON r.id = m.last_reply_id AND r.request_id = m.id AND r.kind = 0
+       WHERE m.id = ${e} AND m.kind = 0`;
+		if (n !== void 0) return n.entity_type !== `Workflow/${u.workflow._tag}` || n.entity_id !== u.executionId || n.tag !== t ? yield* r.die(/* @__PURE__ */ Error("Restart observation belongs to another execution or procedure")) : n;
+	}), g = yield* h(u.delivery.requestId, "run");
+	if (g === void 0) return {
+		kind: "unavailable",
+		reason: "no-journal"
+	};
+	if (((yield* r.sync(() => a.decodeUnknownSync(l)(g.headers)))["voltro-workflow-restart"] ?? null) !== u.delivery.restartToken) return {
+		kind: "unavailable",
+		reason: "delivery-changed"
+	};
+	if (g.reply_id === null || g.payload === null) return {
+		kind: "unavailable",
+		reason: "no-reply"
+	};
+	let _ = t(yield* r.sync(() => JSON.parse(g.payload)));
+	if (_ !== "failed") return {
+		kind: "unavailable",
+		reason: _
+	};
+	let v = /* @__PURE__ */ new Map([[u.delivery.requestId, String(g.reply_id)]]);
+	for (let t of u.activities) {
+		let n = yield* f.requestIdForPrimaryKey({
+			address: m,
+			tag: "activity",
+			id: e(t.name, t.attempt)
+		});
+		if (i.isNone(n)) return {
+			kind: "unavailable",
+			reason: "activity-not-found"
+		};
+		let r = String(n.value), a = yield* h(r, "activity");
+		if (a?.reply_id == null) return {
+			kind: "unavailable",
+			reason: "activity-not-found"
+		};
+		v.set(r, String(a.reply_id));
+	}
+	return {
+		kind: "observed",
+		replies: [...v].map(([e, t]) => ({
+			requestId: e,
+			replyId: t
+		}))
+	};
+}).pipe(r.provideService(o.SafeIntegers, !0));
+//#endregion
+export { u as observeWorkflowRestartReplies };

package/dist/workflowRestartPreparation.js

@@ -0,0 +1,109 @@
+import { readWorkflowRestartCommandInTransaction as e, readWorkflowRestartReservationInTransaction as t, reserveWorkflowRestartInTransaction as n } from "./workflowRestartReservation.js";
+import { Schema as r } from "effect";
+import { eq as i } from "@voltro/database";
+//#region src/workflowRestartPreparation.ts
+var a = async (t) => {
+	if (t.workflow._tag !== t.command.workflowName || t.control.workflowName !== t.command.workflowName) throw Error("Restart preparation requires the matching workflow");
+	let n = await t.transaction(async (n) => {
+		let a = await e(n, t.command);
+		if (a !== void 0) return {
+			kind: "accepted",
+			request: a
+		};
+		let [o] = await n.query({
+			table: "_voltro_workflow_runs",
+			predicate: i("id", t.command.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["runnerGeneration"]
+		});
+		return {
+			kind: "captured",
+			generation: r.decodeUnknownSync(r.NonEmptyString)(o?.runnerGeneration)
+		};
+	});
+	return n.kind === "accepted" ? {
+		kind: "reserved",
+		request: n.request,
+		reused: !0
+	} : s({
+		...t,
+		command: {
+			...t.command,
+			generation: n.generation
+		}
+	});
+}, o = r.Struct({
+	requestId: r.NonEmptyString,
+	restartToken: r.NullOr(r.NonEmptyString)
+}), s = async (e) => {
+	let { command: a } = e;
+	if (e.workflow._tag !== a.workflowName || e.control.workflowName !== a.workflowName) throw Error("Restart preparation requires the matching workflow");
+	let s = await e.transaction(async (n) => {
+		let s = await t(n, a);
+		if (s !== void 0) return {
+			kind: "accepted",
+			request: s
+		};
+		let [c] = await n.query({
+			table: "_voltro_workflow_runs",
+			predicate: i("id", a.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		});
+		if (c === void 0 || c.tag !== a.workflowName || c.runnerGeneration !== a.generation || c.status !== "failed" || c.discardedAt != null || typeof c.executionId != "string" || c.executionId.length === 0) throw Error("Restart preparation requires its failed resident generation");
+		if ((r.decodeUnknownSync(r.NullOr(r.Struct({ tenantId: r.NullOr(r.NonEmptyString) })))(c.subject ?? null)?.tenantId ?? null) !== a.tenantId) throw Error("Restart preparation belongs to another tenant");
+		return {
+			kind: "observe",
+			executionId: c.executionId,
+			delivery: r.decodeUnknownSync(o)(c.engineDelivery),
+			activities: await e.readActivities(n)
+		};
+	});
+	if (s.kind === "accepted") return {
+		kind: "reserved",
+		request: s.request,
+		reused: !0
+	};
+	let c = await e.observe({
+		workflow: e.workflow,
+		executionId: s.executionId,
+		delivery: s.delivery,
+		activities: s.activities
+	});
+	return e.transaction(async (r) => {
+		let o = await t(r, a);
+		if (o !== void 0) return {
+			kind: "reserved",
+			request: o,
+			reused: !0
+		};
+		if (c.kind === "unavailable") return c;
+		let [l] = await r.query({
+			table: "_voltro_workflow_runs",
+			predicate: i("id", a.runId),
+			lock: "update",
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: ["executionId"]
+		});
+		if (l?.executionId !== s.executionId) throw Error("Restart execution changed during observation");
+		return n(r, {
+			...a,
+			token: e.createToken(),
+			delivery: s.delivery,
+			replies: c.replies,
+			control: e.control,
+			paused: await e.readPaused(r),
+			now: e.now
+		});
+	});
+};
+//#endregion
+export { s as prepareWorkflowRestart, a as prepareWorkflowRestartCommand };

package/dist/workflowRestartReservation.js

@@ -0,0 +1,426 @@
+import { resolveAdmissionKeys as e } from "./admission.js";
+import { decodePendingPayload as t, evaluateAdmission as n, recordAdmission as r } from "./admissionStore.js";
+import { resetExpectedWorkflowReplies as i } from "./workflowJournalReset.js";
+import { Effect as a, Schema as o } from "effect";
+import { WorkflowRestartObservationSchema as s, WorkflowRestartSelectionSchema as c, WorkflowRestartTargetSchema as l } from "@voltro/protocol";
+import { and as u, derivedRowId as d, eq as f, id as p, integer as m, json as h, or as g, table as _, text as v, timestamp as y } from "@voltro/database";
+//#region src/workflowRestartReservation.ts
+var b = _("_voltro_workflow_restart_requests", {
+	id: p({ prefix: "wfrs" }),
+	runId: v(),
+	workflowName: v(),
+	executionId: v(),
+	generation: v(),
+	token: v(),
+	ledgerId: v(),
+	tenantId: v().nullable(),
+	delivery: h(),
+	replies: h(),
+	selection: h().nullable(),
+	eviction: h().nullable(),
+	requestedAt: y(),
+	dispatchAttempts: m().default(0),
+	enteredGeneration: v().nullable()
+}).unique(["runId", "generation"]).unique(["runId", "token"]).nonReactive(), x = o.NonEmptyString, S = o.Struct({
+	requestId: x,
+	restartToken: o.NullOr(x)
+}), C = o.Struct({
+	requestId: x,
+	replyId: x
+}), w = c, T = _("_voltro_workflow_restart_withdrawals", {
+	id: p({ prefix: "wfrw" }),
+	runId: v(),
+	workflowName: v(),
+	tenantId: v().nullable(),
+	selection: h(),
+	withdrawnAt: y()
+}).nonReactive(), E = o.Struct({
+	id: o.NonEmptyString,
+	runId: o.NonEmptyString,
+	workflowName: o.NonEmptyString,
+	tenantId: o.NullOr(o.NonEmptyString),
+	selection: w,
+	withdrawnAt: o.Date
+}), D = async (e, t) => {
+	let n = o.decodeUnknownSync(l)(t), [r] = await e.query({
+		table: T.tableName,
+		predicate: f("id", n.requestId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return;
+	let i = o.decodeUnknownSync(E)(r);
+	if (i.runId !== n.runId) throw Error("Restart identity belongs to a different command");
+	if (!Number.isFinite(i.withdrawnAt.getTime())) throw Error("Invalid restart withdrawal timestamp");
+	return i;
+}, O = async (e, t) => {
+	if (await D(e, t) !== void 0) throw Error("Restart request was permanently withdrawn");
+}, k = o.Struct({
+	id: x,
+	runId: x,
+	workflowName: x,
+	executionId: x,
+	generation: x,
+	token: x,
+	ledgerId: x,
+	tenantId: o.NullOr(x),
+	delivery: S,
+	replies: o.Array(C),
+	selection: w,
+	eviction: o.NullOr(o.Struct({
+		executionId: x,
+		runId: o.String
+	})),
+	requestedAt: o.Date,
+	dispatchAttempts: o.Number.check(o.isInt(), o.isGreaterThanOrEqualTo(0)),
+	enteredGeneration: o.NullOr(x)
+}), A = (e, t) => e.kind === t.kind && (e.kind === "failed-steps" || t.kind === "from-step" && e.stepName === t.stepName), j = async (e, t) => {
+	let n = o.decodeUnknownSync(l)(t), [r] = await e.query({
+		table: b.tableName,
+		predicate: f("id", n.requestId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (r === void 0) return;
+	let i = o.decodeUnknownSync(k)(r);
+	if (i.runId !== n.runId) throw Error("Restart identity belongs to a different command");
+	return i;
+}, M = async (e, t) => {
+	let n = await D(e, t);
+	if (n !== void 0) return o.decodeUnknownSync(s)({
+		...t,
+		kind: "withdrawn",
+		workflowName: n.workflowName,
+		selection: n.selection,
+		withdrawnAt: n.withdrawnAt.getTime()
+	});
+	let r = await j(e, t);
+	if (r === void 0) return o.decodeUnknownSync(s)({
+		...t,
+		kind: "not-found"
+	});
+	let i = {
+		requestId: r.id,
+		runId: r.runId,
+		workflowName: r.workflowName,
+		executionId: r.executionId,
+		originalGeneration: r.generation,
+		selection: r.selection,
+		requestedAt: r.requestedAt.getTime(),
+		dispatchAttempts: r.dispatchAttempts
+	};
+	return o.decodeUnknownSync(s)(r.enteredGeneration === null ? {
+		...i,
+		kind: "pending"
+	} : {
+		...i,
+		kind: "entered",
+		enteredGeneration: r.enteredGeneration
+	});
+}, N = async (e, t) => {
+	for (let e of [
+		t.id,
+		t.runId,
+		t.workflowName
+	]) o.decodeUnknownSync(x)(e);
+	if (t.id.length > 64) throw Error("Invalid restart request identity");
+	o.decodeUnknownSync(o.NullOr(x))(t.tenantId);
+	let n = o.decodeUnknownSync(w)(t.selection);
+	await O(e, {
+		requestId: t.id,
+		runId: t.runId
+	});
+	let r = await j(e, {
+		requestId: t.id,
+		runId: t.runId
+	});
+	if (r !== void 0) {
+		if (r.runId !== t.runId || r.workflowName !== t.workflowName || r.tenantId !== t.tenantId || !A(r.selection, n)) throw Error("Restart identity belongs to a different command");
+		return r;
+	}
+}, P = async (e, t) => {
+	let n = o.decodeUnknownSync(E)({
+		...t,
+		withdrawnAt: new Date(t.now)
+	});
+	if (o.decodeUnknownSync(l)({
+		requestId: n.id,
+		runId: n.runId
+	}), !Number.isFinite(n.withdrawnAt.getTime())) throw Error("Invalid restart withdrawal timestamp");
+	let r = await D(e, {
+		requestId: n.id,
+		runId: n.runId
+	});
+	if (r !== void 0) {
+		if (r.workflowName !== n.workflowName || r.tenantId !== n.tenantId || !A(r.selection, n.selection)) throw Error("Restart identity belongs to a different command");
+		return {
+			kind: "withdrawn",
+			withdrawal: r,
+			reused: !0
+		};
+	}
+	let i = await N(e, n);
+	if (i !== void 0) return {
+		kind: "reserved",
+		request: i
+	};
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: f("id", n.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a === void 0 || a.tag !== n.workflowName) throw Error("Restart withdrawal requires its resident workflow");
+	if ((o.decodeUnknownSync(o.NullOr(o.Struct({ tenantId: o.NullOr(x) })))(a.subject ?? null)?.tenantId ?? null) !== n.tenantId) throw Error("Restart withdrawal belongs to another resident tenant");
+	return await e.insert(T.tableName, n), {
+		kind: "withdrawn",
+		withdrawal: n,
+		reused: !1
+	};
+}, F = async (e, t) => {
+	o.decodeUnknownSync(x)(t.generation);
+	let n = await N(e, t);
+	if (n !== void 0 && n.generation !== t.generation) throw Error("Restart identity belongs to a different command");
+	return n;
+}, I = async (i, a) => {
+	for (let e of [
+		a.id,
+		a.runId,
+		a.generation,
+		a.token
+	]) o.decodeUnknownSync(x)(e);
+	if (a.id.length > 64 || !Number.isFinite(new Date(a.now).getTime())) throw Error("Invalid restart request identity or timestamp");
+	await O(i, {
+		requestId: a.id,
+		runId: a.runId
+	});
+	let s = o.decodeUnknownSync(S)(a.delivery), c = o.decodeUnknownSync(w)(a.selection);
+	if (s.restartToken === a.token) throw Error("Restart requires a new delivery token");
+	let l = o.decodeUnknownSync(o.Array(C))(a.replies), d = /* @__PURE__ */ new Map();
+	for (let e of l) {
+		if (!/^[1-9]\d*$/.test(e.requestId) || !/^[1-9]\d*$/.test(e.replyId) || d.has(e.requestId)) throw Error("Restart requires distinct, exact journal reply identities");
+		d.set(e.requestId, e.replyId);
+	}
+	if (!d.has(s.requestId)) throw Error("Restart selection must include its run reply");
+	let [p] = await i.query({
+		table: b.tableName,
+		predicate: f("id", a.id),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (p !== void 0) {
+		let e = o.decodeUnknownSync(k)(p);
+		if (e.runId !== a.runId || e.generation !== a.generation || e.token !== a.token || e.workflowName !== a.control.workflowName || e.tenantId !== a.tenantId || e.delivery.requestId !== s.requestId || e.delivery.restartToken !== s.restartToken || !A(e.selection, c) || e.replies.length !== d.size || e.replies.some((e) => d.get(e.requestId) !== e.replyId)) throw Error("Restart identity belongs to a different request");
+		return {
+			kind: "reserved",
+			request: e,
+			reused: !0
+		};
+	}
+	let [m] = await i.query({
+		table: "_voltro_workflow_runs",
+		predicate: f("id", a.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (m === void 0 || m.tag !== a.control.workflowName || m.runnerGeneration !== a.generation || m.status !== "failed" || m.discardedAt != null || typeof m.executionId != "string" || m.executionId.length === 0) throw Error("Restart requires its undiscarded failed resident generation");
+	if ((o.decodeUnknownSync(o.NullOr(o.Struct({ tenantId: o.NullOr(x) })))(m.subject ?? null)?.tenantId ?? null) !== a.tenantId) throw Error("Restart belongs to another resident tenant");
+	let h = o.decodeUnknownSync(S)(m.engineDelivery);
+	if (h.requestId !== s.requestId || h.restartToken !== s.restartToken) throw Error("Restart journal delivery does not belong to its resident generation");
+	let [_] = await i.query({
+		table: b.tableName,
+		predicate: u(f("runId", a.runId), g(f("generation", a.generation), f("token", a.token))),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id", "generation"]
+	});
+	if (_ !== void 0) {
+		if (_.generation !== a.generation) throw Error("Restart delivery token was already used by this run");
+		return { kind: "already-requested" };
+	}
+	let v = t(i, a.control.workflowName, m.payload), y = e(a.control, v), T = await n({
+		store: i,
+		control: a.control,
+		keys: y,
+		paused: a.paused,
+		now: a.now,
+		reconsidering: !0
+	});
+	if (T.kind !== "admit") return {
+		kind: "not-admitted",
+		decision: T
+	};
+	let E = await r({
+		store: i,
+		control: a.control,
+		keys: y,
+		outcome: "admitted",
+		mode: "restart",
+		reason: T.reason,
+		collapsed: 1,
+		waitedMs: 0,
+		executionId: null,
+		runId: null,
+		tenantId: a.tenantId,
+		now: a.now
+	});
+	if (E === void 0) throw Error("Restart has no admission reservation");
+	let D = o.decodeUnknownSync(k)({
+		id: a.id,
+		runId: a.runId,
+		workflowName: a.control.workflowName,
+		executionId: m.executionId,
+		generation: a.generation,
+		token: a.token,
+		ledgerId: E,
+		tenantId: a.tenantId,
+		delivery: s,
+		replies: l,
+		selection: c,
+		eviction: T.evict ?? null,
+		requestedAt: new Date(a.now),
+		dispatchAttempts: 0,
+		enteredGeneration: null
+	});
+	return await i.insert(b.tableName, D), {
+		kind: "reserved",
+		request: D,
+		reused: !1
+	};
+}, L = async (e, t) => {
+	let [n] = await e.query({
+		table: b.tableName,
+		predicate: f("id", t),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (n === void 0) throw Error("Restart dispatch has no resident request");
+	let r = o.decodeUnknownSync(k)(n);
+	if (r.enteredGeneration !== null) throw Error("Restart request has already entered its resident generation");
+	let [i] = await e.query({
+		table: "_voltro_workflow_admissions",
+		predicate: f("id", r.ledgerId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (i === void 0 || i.outcome !== "admitted" || i.releasedAt !== null || i.workflowName !== r.workflowName || i.tenantId !== r.tenantId || i.executionId !== null || i.runId !== null) throw Error("Restart dispatch has no matching held resident reservation");
+	let [a] = await e.query({
+		table: "_voltro_workflow_runs",
+		predicate: f("id", r.runId),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: void 0
+	});
+	if (a === void 0 || a.tag !== r.workflowName || a.executionId !== r.executionId || a.runnerGeneration !== r.generation || a.status !== "failed" || a.discardedAt != null) throw Error("Restart dispatch no longer owns its failed resident generation");
+	let s = o.decodeUnknownSync(S)(a.engineDelivery);
+	if (s.requestId !== r.delivery.requestId || s.restartToken !== r.delivery.restartToken) throw Error("Restart dispatch no longer owns its journal delivery");
+	return {
+		request: r,
+		run: a
+	};
+}, R = async (e, t) => {
+	let { request: n } = await L(e, t), r = n.dispatchAttempts + 1;
+	if (!Number.isSafeInteger(r)) throw Error("Restart dispatch attempt counter exhausted");
+	if (await e.update(b.tableName, t, { dispatchAttempts: r }) === null) throw Error("Restart request disappeared before dispatch");
+	return {
+		...n,
+		dispatchAttempts: r
+	};
+}, z = (e) => a.gen(function* () {
+	let { request: t } = yield* a.promise(() => e.transaction((t) => L(t, e.requestId)));
+	if (!(yield* a.promise(() => e.acquireCapacity(t)))) return { kind: "waiting-capacity" };
+	let n = yield* a.promise(() => e.transaction((e) => R(e, t.id)));
+	return yield* i(n.replies, {
+		requestId: n.delivery.requestId,
+		previousToken: n.delivery.restartToken,
+		token: n.token,
+		workflowName: n.workflowName,
+		executionId: n.executionId
+	});
+}), B = async (e, t) => {
+	for (let e of [
+		t.runId,
+		t.workflowName,
+		t.executionId,
+		t.generation
+	]) o.decodeUnknownSync(x)(e);
+	if (!Number.isFinite(new Date(t.now).getTime())) throw Error("Restart entry requires a valid timestamp");
+	let n = o.decodeUnknownSync(S)(t.delivery);
+	if (n.restartToken === null) throw Error("Restart entry has no delivery token");
+	let [r] = await e.query({
+		table: b.tableName,
+		predicate: u(f("runId", t.runId), f("token", n.restartToken)),
+		lock: "update",
+		order: [],
+		take: 1,
+		skip: void 0,
+		projection: ["id"]
+	});
+	if (r === void 0) throw Error("Restart delivery has no matching resident request");
+	let { request: i, run: a } = await L(e, o.decodeUnknownSync(x)(r.id));
+	if (i.runId !== t.runId || i.workflowName !== t.workflowName || i.executionId !== t.executionId || i.generation === t.generation || i.delivery.requestId !== n.requestId || i.token !== n.restartToken) throw Error("Restart entry does not match its reserved delivery");
+	if (i.dispatchAttempts === 0) throw Error("Restart entry has no committed dispatch attempt");
+	if (await e.update("_voltro_workflow_admissions", i.ledgerId, {
+		executionId: i.executionId,
+		runId: i.runId
+	}) === null) throw Error("Restart reservation disappeared during entry");
+	if (await e.update(b.tableName, i.id, { enteredGeneration: t.generation }) === null) throw Error("Restart request disappeared during entry");
+	let s = await e.update("_voltro_workflow_runs", i.runId, {
+		runnerGeneration: t.generation,
+		engineDelivery: n,
+		runnerEnteredAt: new Date(t.now),
+		reclaimCount: 0,
+		status: "running",
+		errorTag: null,
+		errorMessage: null,
+		output: null,
+		completedAt: null,
+		durationMs: null
+	});
+	if (s === null) throw Error("Restart run disappeared during entry");
+	return {
+		row: s,
+		previous: a,
+		event: await e.insert("_voltro_workflow_run_events", {
+			id: d("wfev", JSON.stringify(["restart", i.id])),
+			runId: i.runId,
+			eventType: "run-redriven",
+			occurredAt: new Date(t.now),
+			stepName: null,
+			attempt: null,
+			payload: {
+				requestId: i.id,
+				executionId: i.executionId,
+				previousGeneration: i.generation,
+				generation: t.generation
+			}
+		})
+	};
+};
+//#endregion
+export { R as beginWorkflowRestartDispatchInTransaction, B as consumeWorkflowRestartInTransaction, N as readWorkflowRestartCommandInTransaction, M as readWorkflowRestartObservationInTransaction, F as readWorkflowRestartReservationInTransaction, I as reserveWorkflowRestartInTransaction, z as resetReservedWorkflowJournal, P as withdrawWorkflowRestartInTransaction, b as workflowRestartRequestsTable, T as workflowRestartWithdrawalsTable };

package/dist/workflowResumeDispatch.js

@@ -0,0 +1,29 @@
+import { beginWorkflowControlDispatchInTransaction as e, bindWorkflowResumeJournalInTransaction as t } from "./controlRequest.js";
+import { observeWorkflowSuspension as n, resetExpectedWorkflowSuspension as r } from "./workflowJournalReset.js";
+import { Context as i, Effect as a } from "effect";
+import { SqlClient as o } from "effect/sql";
+import { Sharding as s } from "effect/cluster";
+//#region src/workflowResumeDispatch.ts
+var c = (i) => a.gen(function* () {
+	let o = yield* a.context(), c = yield* a.promise(() => i.transaction((e) => t(e, i.requestId, (e) => a.runPromiseWith(o)(n(e)))));
+	if (c.kind !== "bound") return c;
+	let l = yield* a.promise(() => i.transaction((t) => e(t, i.requestId)));
+	if (l.kind !== "dispatch") return l;
+	let { request: u } = l;
+	if (u.operation !== "resume" || u.resumeJournal === null) return yield* a.die(/* @__PURE__ */ Error("Resume dispatch requires its committed suspension binding"));
+	let d = yield* r({
+		workflowName: u.workflowName,
+		executionId: u.executionId,
+		...u.resumeJournal
+	});
+	return yield* (yield* s.Sharding).pollStorage, {
+		kind: "attempted",
+		request: u,
+		journal: d
+	};
+}), l = class extends i.Service()("@voltro/workflow/WorkflowResumeDispatcher") {}, u = a.gen(function* () {
+	let e = yield* o.SqlClient, t = yield* s.Sharding;
+	return l.of({ dispatch: (n) => c(n).pipe(a.provideService(o.SqlClient, e), a.provideService(s.Sharding, t)) });
+});
+//#endregion
+export { l as WorkflowResumeDispatcher, c as dispatchWorkflowResume, u as makeWorkflowResumeDispatcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/workflow",
-  "version": "0.85.0",
+  "version": "0.86.0",
   "description": "Durable workflows for Voltro — the workflow() descriptor + step() / awaitSignal primitives over @effect/cluster, with a browser-safe define subpath.",
   "keywords": [
     "voltro",
@@ -48,9 +48,9 @@
     "node": ">=24.0.0"
   },
   "dependencies": {
-    "@voltro/database": "0.85.0",
-    "@voltro/logger": "0.85.0",
-    "@voltro/protocol": "0.85.0"
+    "@voltro/database": "0.86.0",
+    "@voltro/logger": "0.86.0",
+    "@voltro/protocol": "0.86.0"
   },
   "peerDependencies": {
     "effect": "4.0.1",