@fragno-dev/workflows 0.0.1

package/dist/node/definition.js

@@ -0,0 +1,551 @@
+import { workflowsSchema } from "./schema.js";
+import { defineFragment } from "@fragno-dev/core";
+import { dbNow, withDatabase } from "@fragno-dev/db";
+
+//#region src/definition.ts
+const DEFAULT_PAGE_SIZE = 25;
+const INSTANCE_STATUSES = new Set([
+	"queued",
+	"running",
+	"paused",
+	"errored",
+	"terminated",
+	"complete",
+	"waiting",
+	"waitingForPause",
+	"unknown"
+]);
+const TERMINAL_STATUSES = new Set([
+	"complete",
+	"terminated",
+	"errored"
+]);
+const PAUSED_STATUSES = new Set(["paused", "waitingForPause"]);
+function generateInstanceId(nowMs, randomFloat) {
+	return `inst_${nowMs.toString(36)}_${randomFloat().toString(36).slice(2, 10)}`;
+}
+function buildInstanceStatus(instance) {
+	return {
+		status: INSTANCE_STATUSES.has(instance.status) ? instance.status : "unknown",
+		error: instance.errorName || instance.errorMessage ? {
+			name: instance.errorName ?? "Error",
+			message: instance.errorMessage ?? ""
+		} : void 0,
+		output: instance.output ?? void 0
+	};
+}
+function buildInstanceMetadata(instance) {
+	return {
+		workflowName: instance.workflowName,
+		runNumber: instance.runNumber,
+		params: instance.params ?? {},
+		pauseRequested: instance.pauseRequested,
+		createdAt: instance.createdAt,
+		updatedAt: instance.updatedAt,
+		startedAt: instance.startedAt,
+		completedAt: instance.completedAt
+	};
+}
+function buildCurrentStepSummary(step) {
+	const error = step.errorName || step.errorMessage ? {
+		name: step.errorName ?? "Error",
+		message: step.errorMessage ?? ""
+	} : void 0;
+	return {
+		stepKey: step.stepKey,
+		name: step.name,
+		type: step.type,
+		status: step.status,
+		attempts: step.attempts,
+		maxAttempts: step.maxAttempts,
+		timeoutMs: step.timeoutMs,
+		nextRetryAt: step.nextRetryAt,
+		wakeAt: step.wakeAt,
+		waitEventType: step.waitEventType,
+		error
+	};
+}
+function buildStepHistoryEntry(step) {
+	const error = step.errorName || step.errorMessage ? {
+		name: step.errorName ?? "Error",
+		message: step.errorMessage ?? ""
+	} : void 0;
+	return {
+		id: step.id.toString(),
+		runNumber: step.runNumber,
+		stepKey: step.stepKey,
+		name: step.name,
+		type: step.type,
+		status: step.status,
+		attempts: step.attempts,
+		maxAttempts: step.maxAttempts,
+		timeoutMs: step.timeoutMs,
+		nextRetryAt: step.nextRetryAt,
+		wakeAt: step.wakeAt,
+		waitEventType: step.waitEventType,
+		result: step.result ?? null,
+		error,
+		createdAt: step.createdAt,
+		updatedAt: step.updatedAt
+	};
+}
+function buildEventHistoryEntry(event) {
+	return {
+		id: event.id.toString(),
+		runNumber: event.runNumber,
+		type: event.type,
+		payload: event.payload ?? null,
+		createdAt: event.createdAt,
+		deliveredAt: event.deliveredAt,
+		consumedByStepKey: event.consumedByStepKey
+	};
+}
+function buildLogHistoryEntry(log) {
+	return {
+		id: log.id.toString(),
+		runNumber: log.runNumber,
+		stepKey: log.stepKey,
+		attempt: log.attempt,
+		level: log.level,
+		category: log.category,
+		message: log.message,
+		data: log.data ?? null,
+		createdAt: log.createdAt
+	};
+}
+function isTerminalStatus(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+function isPausedStatus(status) {
+	return PAUSED_STATUSES.has(status);
+}
+const workflowsFragmentDefinition = defineFragment("workflows").extend(withDatabase(workflowsSchema)).provideHooks(({ defineHook, config }) => ({ onWorkflowEnqueued: defineHook(async function(_payload) {
+	await config.runner?.tick();
+}) })).providesBaseService(({ defineService, config, deps }) => {
+	const getNow = () => config.runtime.time.now();
+	const getDbNow = async () => deps.db.now ? deps.db.now() : getNow();
+	const getRunAtNow = () => config.dbNow?.() ?? dbNow();
+	const randomFloat = () => config.runtime.random.float();
+	const workflowsByName = /* @__PURE__ */ new Map();
+	for (const entry of Object.values(config.workflows ?? {})) workflowsByName.set(entry.name, entry);
+	const validateWorkflowParams = async (workflowName, params) => {
+		const entry = workflowsByName.get(workflowName);
+		if (!entry) throw new Error("WORKFLOW_NOT_FOUND");
+		if ("workflow" in entry) return params ?? {};
+		if (!entry.schema) return params ?? {};
+		const result = await entry.schema["~standard"].validate(params ?? {});
+		if (result.issues) {
+			const error = /* @__PURE__ */ new Error("WORKFLOW_PARAMS_INVALID");
+			error.issues = result.issues;
+			throw error;
+		}
+		return result.value;
+	};
+	return defineService({
+		getDbNow,
+		validateWorkflowParams,
+		createInstance: function(workflowName, options) {
+			const now = getNow();
+			const instanceId = options?.id ?? generateInstanceId(now.getTime(), randomFloat);
+			const params = options?.params ?? {};
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [existing] }) => {
+				if (existing) throw new Error("INSTANCE_ID_ALREADY_EXISTS");
+				const instanceRef = uow.create("workflow_instance", {
+					workflowName,
+					instanceId,
+					status: "queued",
+					params,
+					pauseRequested: false,
+					retentionUntil: null,
+					runNumber: 0,
+					startedAt: null,
+					completedAt: null,
+					output: null,
+					errorName: null,
+					errorMessage: null
+				});
+				uow.create("workflow_task", {
+					instanceRef,
+					workflowName,
+					instanceId,
+					runNumber: 0,
+					kind: "run",
+					runAt: getRunAtNow(),
+					status: "pending",
+					attempts: 0,
+					maxAttempts: 1,
+					lastError: null,
+					lockedUntil: null,
+					lockOwner: null
+				});
+				uow.triggerHook("onWorkflowEnqueued", {
+					workflowName,
+					instanceId,
+					reason: "create"
+				});
+				return {
+					id: instanceId,
+					details: buildInstanceStatus({
+						status: "queued",
+						output: null,
+						errorName: null,
+						errorMessage: null
+					})
+				};
+			}).build();
+		},
+		createBatch: function(workflowName, instances) {
+			if (instances.length === 0) return Promise.resolve([]);
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.find("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "in", instances.map((instance) => instance.id)))))).mutate(({ uow, retrieveResult: [existingInstances] }) => {
+				const existingIds = new Set(existingInstances.map((record) => record.instanceId));
+				const processedIds = /* @__PURE__ */ new Set();
+				const created = [];
+				for (const instance of instances) {
+					if (existingIds.has(instance.id) || processedIds.has(instance.id)) continue;
+					processedIds.add(instance.id);
+					const instanceRef = uow.create("workflow_instance", {
+						workflowName,
+						instanceId: instance.id,
+						status: "queued",
+						params: instance.params ?? {},
+						pauseRequested: false,
+						retentionUntil: null,
+						runNumber: 0,
+						startedAt: null,
+						completedAt: null,
+						output: null,
+						errorName: null,
+						errorMessage: null
+					});
+					uow.create("workflow_task", {
+						instanceRef,
+						workflowName,
+						instanceId: instance.id,
+						runNumber: 0,
+						kind: "run",
+						runAt: getRunAtNow(),
+						status: "pending",
+						attempts: 0,
+						maxAttempts: 1,
+						lastError: null,
+						lockedUntil: null,
+						lockOwner: null
+					});
+					uow.triggerHook("onWorkflowEnqueued", {
+						workflowName,
+						instanceId: instance.id,
+						reason: "create"
+					});
+					created.push({
+						id: instance.id,
+						details: buildInstanceStatus({
+							status: "queued",
+							output: null,
+							errorName: null,
+							errorMessage: null
+						})
+					});
+				}
+				return created;
+			}).build();
+		},
+		getInstanceStatus: function(workflowName, instanceId) {
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).transformRetrieve(([instance]) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				return buildInstanceStatus(instance);
+			}).build();
+		},
+		getInstanceMetadata: function(workflowName, instanceId) {
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).transformRetrieve(([instance]) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				return buildInstanceMetadata(instance);
+			}).build();
+		},
+		getInstanceCurrentStep: function({ workflowName, instanceId, runNumber }) {
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findWithCursor("workflow_step", (b) => {
+				return b.whereIndex("idx_workflow_step_history_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber))).orderByIndex("idx_workflow_step_history_createdAt", "desc").pageSize(1);
+			})).transformRetrieve(([steps]) => {
+				const latest = steps.items[0];
+				return latest ? buildCurrentStepSummary(latest) : void 0;
+			}).build();
+		},
+		getInstanceRunNumber: function(workflowName, instanceId) {
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).transformRetrieve(([instance]) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				return instance.runNumber;
+			}).build();
+		},
+		listInstances: function({ workflowName, status, pageSize = DEFAULT_PAGE_SIZE, cursor, order = "desc" }) {
+			const effectivePageSize = cursor?.pageSize ?? pageSize;
+			const effectiveOrder = cursor?.orderDirection ?? order;
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findWithCursor("workflow_instance", (b) => {
+				if (status) {
+					const query$1 = b.whereIndex("idx_workflow_instance_status_updatedAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("status", "=", status))).orderByIndex("idx_workflow_instance_status_updatedAt", effectiveOrder).pageSize(effectivePageSize);
+					return cursor ? query$1.after(cursor) : query$1;
+				}
+				const query = b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb("workflowName", "=", workflowName)).orderByIndex("idx_workflow_instance_workflowName_instanceId", effectiveOrder).pageSize(effectivePageSize);
+				return cursor ? query.after(cursor) : query;
+			})).transformRetrieve(([instances]) => {
+				return {
+					instances: instances.items.map((instance) => ({
+						id: instance.instanceId,
+						details: buildInstanceStatus(instance),
+						createdAt: instance.createdAt
+					})),
+					cursor: instances.cursor,
+					hasNextPage: instances.hasNextPage
+				};
+			}).build();
+		},
+		listHistory: function({ workflowName, instanceId, runNumber, pageSize = DEFAULT_PAGE_SIZE, stepsCursor, eventsCursor, includeLogs, logsCursor, logLevel, logCategory, order = "desc" }) {
+			const stepsOrder = stepsCursor?.orderDirection ?? order;
+			const eventsOrder = eventsCursor?.orderDirection ?? order;
+			const logsOrder = logsCursor?.orderDirection ?? order;
+			const stepsPageSize = stepsCursor?.pageSize ?? pageSize;
+			const eventsPageSize = eventsCursor?.pageSize ?? pageSize;
+			const logsPageSize = logsCursor?.pageSize ?? pageSize;
+			return this.serviceTx(workflowsSchema).retrieve((uow) => {
+				let chain = uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId)))).findWithCursor("workflow_step", (b) => {
+					const query = b.whereIndex("idx_workflow_step_history_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber))).orderByIndex("idx_workflow_step_history_createdAt", stepsOrder).pageSize(stepsPageSize);
+					return stepsCursor ? query.after(stepsCursor) : query;
+				}).findWithCursor("workflow_event", (b) => {
+					const query = b.whereIndex("idx_workflow_event_history_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber))).orderByIndex("idx_workflow_event_history_createdAt", eventsOrder).pageSize(eventsPageSize);
+					return eventsCursor ? query.after(eventsCursor) : query;
+				});
+				const effectiveLogLevel = includeLogs ? logLevel : void 0;
+				const effectiveLogCategory = includeLogs ? logCategory : void 0;
+				const effectiveLogsCursor = includeLogs ? logsCursor : void 0;
+				const effectiveLogsPageSize = includeLogs ? logsPageSize : 1;
+				return chain.findWithCursor("workflow_log", (b) => {
+					if (effectiveLogLevel) {
+						const query$1 = b.whereIndex("idx_workflow_log_level_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber), eb("level", "=", effectiveLogLevel))).orderByIndex("idx_workflow_log_level_createdAt", logsOrder).pageSize(effectiveLogsPageSize);
+						return effectiveLogsCursor ? query$1.after(effectiveLogsCursor) : query$1;
+					}
+					if (effectiveLogCategory) {
+						const query$1 = b.whereIndex("idx_workflow_log_category_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber), eb("category", "=", effectiveLogCategory))).orderByIndex("idx_workflow_log_category_createdAt", logsOrder).pageSize(effectiveLogsPageSize);
+						return effectiveLogsCursor ? query$1.after(effectiveLogsCursor) : query$1;
+					}
+					const query = b.whereIndex("idx_workflow_log_history_createdAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("runNumber", "=", runNumber))).orderByIndex("idx_workflow_log_history_createdAt", logsOrder).pageSize(effectiveLogsPageSize);
+					return effectiveLogsCursor ? query.after(effectiveLogsCursor) : query;
+				});
+			}).mutate(({ retrieveResult }) => {
+				const [instance, steps, events, logs] = retrieveResult;
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				const filteredLogs = includeLogs && logLevel && logCategory ? logs?.items.filter((log) => log.category === logCategory) : logs?.items;
+				return {
+					runNumber,
+					steps: steps.items.map(buildStepHistoryEntry),
+					events: events.items.map(buildEventHistoryEntry),
+					stepsCursor: steps.cursor,
+					stepsHasNextPage: steps.hasNextPage,
+					eventsCursor: events.cursor,
+					eventsHasNextPage: events.hasNextPage,
+					logs: includeLogs ? filteredLogs?.map(buildLogHistoryEntry) ?? [] : void 0,
+					logsCursor: includeLogs ? logs.cursor : void 0,
+					logsHasNextPage: includeLogs ? logs.hasNextPage : void 0
+				};
+			}).build();
+		},
+		pauseInstance: function(workflowName, instanceId) {
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [instance] }) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				const currentStatus = buildInstanceStatus(instance).status;
+				if (isTerminalStatus(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+				if (currentStatus === "running") {
+					uow.update("workflow_instance", instance.id, (b) => b.set({
+						status: "waitingForPause",
+						pauseRequested: true,
+						updatedAt: getNow()
+					}).check());
+					return buildInstanceStatus({
+						status: "waitingForPause",
+						output: instance.output,
+						errorName: instance.errorName,
+						errorMessage: instance.errorMessage
+					});
+				}
+				if (currentStatus === "queued" || currentStatus === "waiting") {
+					uow.update("workflow_instance", instance.id, (b) => b.set({
+						status: "paused",
+						pauseRequested: false,
+						updatedAt: getNow()
+					}).check());
+					return buildInstanceStatus({
+						status: "paused",
+						output: instance.output,
+						errorName: instance.errorName,
+						errorMessage: instance.errorMessage
+					});
+				}
+				return buildInstanceStatus(instance);
+			}).build();
+		},
+		resumeInstance: function(workflowName, instanceId) {
+			const now = getNow();
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId)))).find("workflow_task", (b) => b.whereIndex("idx_workflow_task_workflowName_instanceId_runNumber", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [instance, tasks] }) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				if (buildInstanceStatus(instance).status !== "paused") return buildInstanceStatus(instance);
+				const task = tasks.find((candidate) => candidate.runNumber === instance.runNumber);
+				uow.update("workflow_instance", instance.id, (b) => b.set({
+					status: "queued",
+					pauseRequested: false,
+					updatedAt: now
+				}).check());
+				if (task) uow.update("workflow_task", task.id, (b) => b.set({
+					kind: "resume",
+					runAt: getRunAtNow(),
+					status: "pending",
+					attempts: 0,
+					lastError: null,
+					lockedUntil: null,
+					lockOwner: null,
+					updatedAt: now
+				}).check());
+				else uow.create("workflow_task", {
+					instanceRef: instance.id,
+					workflowName,
+					instanceId,
+					runNumber: instance.runNumber,
+					kind: "resume",
+					runAt: getRunAtNow(),
+					status: "pending",
+					attempts: 0,
+					maxAttempts: 1,
+					lastError: null,
+					lockedUntil: null,
+					lockOwner: null
+				});
+				uow.triggerHook("onWorkflowEnqueued", {
+					workflowName,
+					instanceId,
+					reason: "resume"
+				});
+				return buildInstanceStatus({
+					status: "queued",
+					output: instance.output,
+					errorName: instance.errorName,
+					errorMessage: instance.errorMessage
+				});
+			}).build();
+		},
+		terminateInstance: function(workflowName, instanceId) {
+			const now = getNow();
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [instance] }) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				const currentStatus = buildInstanceStatus(instance).status;
+				if (isTerminalStatus(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+				uow.update("workflow_instance", instance.id, (b) => b.set({
+					status: "terminated",
+					completedAt: now,
+					updatedAt: now,
+					pauseRequested: false
+				}).check());
+				return buildInstanceStatus({
+					status: "terminated",
+					output: instance.output,
+					errorName: instance.errorName,
+					errorMessage: instance.errorMessage
+				});
+			}).build();
+		},
+		restartInstance: function(workflowName, instanceId) {
+			const now = getNow();
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [instance] }) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				const nextRun = instance.runNumber + 1;
+				uow.update("workflow_instance", instance.id, (b) => b.set({
+					status: "queued",
+					pauseRequested: false,
+					runNumber: nextRun,
+					startedAt: null,
+					completedAt: null,
+					output: null,
+					errorName: null,
+					errorMessage: null,
+					updatedAt: now
+				}).check());
+				uow.create("workflow_task", {
+					instanceRef: instance.id,
+					workflowName,
+					instanceId,
+					runNumber: nextRun,
+					kind: "run",
+					runAt: getRunAtNow(),
+					status: "pending",
+					attempts: 0,
+					maxAttempts: 1,
+					lastError: null,
+					lockedUntil: null,
+					lockOwner: null
+				});
+				uow.triggerHook("onWorkflowEnqueued", {
+					workflowName,
+					instanceId,
+					reason: "create"
+				});
+				return buildInstanceStatus({
+					status: "queued",
+					output: null,
+					errorName: null,
+					errorMessage: null
+				});
+			}).build();
+		},
+		sendEvent: function(workflowName, instanceId, options) {
+			const now = getNow();
+			return this.serviceTx(workflowsSchema).retrieve((uow) => uow.findFirst("workflow_instance", (b) => b.whereIndex("idx_workflow_instance_workflowName_instanceId", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId)))).find("workflow_step", (b) => b.whereIndex("idx_workflow_step_status_wakeAt", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId), eb("status", "=", "waiting"), eb.or(eb.isNull("wakeAt"), eb("wakeAt", ">", dbNow()))))).find("workflow_task", (b) => b.whereIndex("idx_workflow_task_workflowName_instanceId_runNumber", (eb) => eb.and(eb("workflowName", "=", workflowName), eb("instanceId", "=", instanceId))))).mutate(({ uow, retrieveResult: [instance, steps, tasks] }) => {
+				if (!instance) throw new Error("INSTANCE_NOT_FOUND");
+				const currentStatus = buildInstanceStatus(instance).status;
+				if (isTerminalStatus(currentStatus)) throw new Error("INSTANCE_TERMINAL");
+				uow.create("workflow_event", {
+					instanceRef: instance.id,
+					workflowName,
+					instanceId,
+					runNumber: instance.runNumber,
+					type: options.type,
+					payload: options.payload ?? null,
+					deliveredAt: null,
+					consumedByStepKey: null
+				});
+				const currentRunSteps = steps.filter((step) => step.runNumber === instance.runNumber);
+				const currentTask = tasks.find((candidate) => candidate.runNumber === instance.runNumber);
+				if (currentStatus === "waiting" && !isPausedStatus(currentStatus) && currentRunSteps.some((step) => step.waitEventType === options.type)) {
+					if (currentTask) uow.update("workflow_task", currentTask.id, (b) => b.set({
+						kind: "wake",
+						runAt: getRunAtNow(),
+						status: "pending",
+						attempts: 0,
+						lastError: null,
+						lockedUntil: null,
+						lockOwner: null,
+						updatedAt: now
+					}).check());
+					else uow.create("workflow_task", {
+						instanceRef: instance.id,
+						workflowName,
+						instanceId,
+						runNumber: instance.runNumber,
+						kind: "wake",
+						runAt: getRunAtNow(),
+						status: "pending",
+						attempts: 0,
+						maxAttempts: 1,
+						lastError: null,
+						lockedUntil: null,
+						lockOwner: null
+					});
+					uow.triggerHook("onWorkflowEnqueued", {
+						workflowName,
+						instanceId,
+						reason: "event"
+					});
+				}
+				return buildInstanceStatus(instance);
+			}).build();
+		}
+	});
+}).build();
+
+//#endregion
+export { workflowsFragmentDefinition };
+//# sourceMappingURL=definition.js.map