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

package/dist/workflowResumeDispatch.js

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

package/dist/workflowRuntimeReadiness.js

@@ -0,0 +1,12 @@
+import { JournalRoutingGuard as e } from "./journalRoutingGuard.js";
+import { Context as t, Effect as n, Option as r } from "effect";
+import { Sharding as i } from "effect/cluster";
+//#region src/workflowRuntimeReadiness.ts
+var a = class extends t.Service()("@voltro/workflow/WorkflowRuntimeReadiness") {}, o = n.gen(function* () {
+	let t = yield* i.Sharding, a = r.getOrUndefined(yield* n.serviceOption(e)), o = !0;
+	return yield* n.addFinalizer(() => n.sync(() => {
+		o = !1;
+	})), { isReady: () => o && !a?.isClosed() && !n.runSync(t.isShutdown) };
+}), s = n.map(n.serviceOption(a), (e) => r.isSome(e) ? e.value.isReady : () => !0);
+//#endregion
+export { a as WorkflowRuntimeReadiness, s as captureWorkflowRuntimeReadiness, o as makeWorkflowRuntimeReadiness };