@temelj/workflow 0.0.0-alpha.1

package/dist/engine/observation.mjs

@@ -0,0 +1,201 @@
+import { makeWorkflowStepAttemptKey } from "../history/attempt-key.mjs";
+import { observeTelemetry } from "../telemetry.mjs";
+import { getWorkflowEventStepAttemptKey } from "../events/descriptors.mjs";
+import "../history/mod.mjs";
+import { createWorkflowStepAttempts } from "../history/step-attempts.mjs";
+import { createPubSub } from "@temelj/event";
+//#region src/engine/observation.ts
+function createObservationEmitter(telemetry) {
+	return new ObservationEmitter(telemetry);
+}
+var ObservationEmitter = class {
+	#events = createPubSub();
+	#telemetry;
+	#emit = (event, payload) => {
+		this.#events.emit(event, payload);
+		observeTelemetry(this.#telemetry, event, payload);
+	};
+	constructor(telemetry) {
+		this.#telemetry = telemetry;
+		this.on = this.on.bind(this);
+		this.once = this.once.bind(this);
+		this.off = this.off.bind(this);
+		this.listeners = this.listeners.bind(this);
+		this.clearListeners = this.clearListeners.bind(this);
+		this.listenerCount = this.listenerCount.bind(this);
+		this.emitRunEvent = this.emitRunEvent.bind(this);
+		this.emitRunMetadataUpdated = this.emitRunMetadataUpdated.bind(this);
+		this.emitDurableEventAppended = this.emitDurableEventAppended.bind(this);
+		this.emitMessageSent = this.emitMessageSent.bind(this);
+		this.emitHookResumed = this.emitHookResumed.bind(this);
+		this.emitWebhookResumed = this.emitWebhookResumed.bind(this);
+		this.emitChildWorkflowStarted = this.emitChildWorkflowStarted.bind(this);
+		this.emitCleanupCompleted = this.emitCleanupCompleted.bind(this);
+		this.emitRetentionApplied = this.emitRetentionApplied.bind(this);
+		this.emitWorkerOperation = this.emitWorkerOperation.bind(this);
+		this.emitScheduleTicked = this.emitScheduleTicked.bind(this);
+		this.emitScheduleRunCreated = this.emitScheduleRunCreated.bind(this);
+	}
+	on(pattern, handler) {
+		return this.#events.on(pattern, handler);
+	}
+	once(pattern, handler) {
+		return this.#events.once(pattern, handler);
+	}
+	off(pattern, handler) {
+		this.#events.off(pattern, handler);
+	}
+	clearListeners(pattern) {
+		this.#events.clear(pattern);
+	}
+	listenerCount(pattern) {
+		return this.#events.listenerCount(pattern);
+	}
+	listeners(pattern) {
+		return pattern === void 0 ? this.#events.listeners() : this.#events.listeners(pattern);
+	}
+	emitRunEvent(run, previousRun) {
+		emitRunEvent(this.#emit, run, previousRun);
+	}
+	emitRunMetadataUpdated(run, previousRun) {
+		this.#emit("workflow:run-metadata-updated", makeRunObservationEvent(run, previousRun));
+	}
+	emitDurableEventAppended(runId, event, appendedEvents) {
+		this.#emit("workflow:durable-event-appended", {
+			runId,
+			event,
+			events: appendedEvents
+		});
+		emitStepAttemptUpdated(this.#emit, runId, event, appendedEvents);
+		emitStreamUpdated(this.#emit, runId, event);
+	}
+	emitMessageSent(runId, event) {
+		this.#emit("workflow:message-sent", {
+			runId,
+			messageId: event.messageId,
+			payload: event.payload,
+			timestamp: event.timestamp,
+			...event.telemetryContext === void 0 ? {} : { traceContext: event.telemetryContext }
+		});
+	}
+	emitHookResumed(runId, messageId, payload, traceContext) {
+		this.#emit("workflow:hook-resumed", {
+			runId,
+			messageId,
+			...payload === void 0 ? {} : { payload },
+			...traceContext === void 0 ? {} : { traceContext }
+		});
+	}
+	emitWebhookResumed(runId, messageId, payload, traceContext) {
+		this.#emit("workflow:webhook-resumed", {
+			runId,
+			messageId,
+			...payload === void 0 ? {} : { payload },
+			...traceContext === void 0 ? {} : { traceContext }
+		});
+	}
+	emitChildWorkflowStarted(event) {
+		this.#emit("workflow:child-workflow-started", event);
+	}
+	emitCleanupCompleted(result) {
+		this.#emit("workflow:cleanup-completed", { result });
+	}
+	emitRetentionApplied(result) {
+		this.#emit("workflow:retention-applied", { result });
+	}
+	emitWorkerOperation(event) {
+		this.#emit("workflow:worker-operation", event);
+	}
+	emitScheduleTicked(event) {
+		this.#emit("workflow:schedule-ticked", event);
+	}
+	emitScheduleRunCreated(event) {
+		this.#emit("workflow:schedule-run-created", event);
+	}
+};
+function emitStepAttemptUpdated(emit, runId, event, events) {
+	let key;
+	try {
+		key = getWorkflowEventStepAttemptKey(event);
+	} catch {
+		return;
+	}
+	if (key === void 0) return;
+	const attempt = createWorkflowStepAttempts(runId, events).find((current) => makeWorkflowStepAttemptKey(current.stepId, current.attempt) === key);
+	if (attempt === void 0) return;
+	emit("workflow:step-attempt-updated", {
+		runId,
+		attempt
+	});
+}
+function emitStreamUpdated(emit, runId, event) {
+	if (event.kind !== "stream_started" && event.kind !== "stream_chunk" && event.kind !== "stream_closed" && event.kind !== "stream_failed") return;
+	emit("workflow:stream-updated", {
+		runId,
+		streamId: event.streamId,
+		streamName: event.stepName,
+		eventKind: event.kind,
+		timestamp: event.timestamp,
+		stepId: event.stepId,
+		stepName: event.stepName,
+		...event.kind === "stream_chunk" ? { index: event.index } : {},
+		...event.kind === "stream_failed" ? { error: event.error } : {}
+	});
+}
+function emitRunEvent(emit, run, previousRun) {
+	const payload = makeRunObservationEvent(run, previousRun);
+	switch (run.lastTransitionReason) {
+		case "created":
+			emit("workflow:run-created", payload);
+			break;
+		case "claimed":
+		case "reclaimed":
+			emit("workflow:run-claimed", payload);
+			break;
+		case "started":
+			emit("workflow:run-started", payload);
+			break;
+		case "waiting":
+		case "missing_implementation":
+			emit("workflow:run-waiting", payload);
+			break;
+		case "rescheduled":
+			emit("workflow:run-rescheduled", payload);
+			break;
+		case "lease_released":
+			emit("workflow:run-lease-released", payload);
+			break;
+		case "manual_retry":
+			emit("workflow:run-manual-retry", payload);
+			break;
+		case "permanent_failure":
+			emit("workflow:run-permanently-failed", payload);
+			break;
+		case "retry":
+			emit("workflow:run-retrying", payload);
+			break;
+		case "completed":
+			emit("workflow:run-completed", payload);
+			break;
+		case "failed":
+		case "deadline":
+			emit("workflow:run-failed", payload);
+			break;
+		case "canceled":
+			emit("workflow:run-canceled", payload);
+			break;
+	}
+}
+function makeRunObservationEvent(run, previousRun) {
+	return {
+		run,
+		previousRun,
+		status: run.status,
+		reason: run.lastTransitionReason,
+		timestamp: run.lastTransitionAt,
+		workflowName: run.workflowName,
+		...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion }
+	};
+}
+//#endregion
+export { ObservationEmitter, createObservationEmitter };

package/dist/engine/recovery.d.mts

@@ -0,0 +1,26 @@
+import { ScheduleRecord } from "../types/schedule.mjs";
+import { LockRecord } from "../types/lock.mjs";
+import { WorkflowRecoverySummary } from "../types/summary.mjs";
+import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { WorkflowRecoveryWaitInputs } from "./summary/recovery-waits.mjs";
+//#region src/engine/recovery.d.ts
+interface WorkflowRecoverySummaryInputs extends WorkflowRecoveryWaitInputs {
+  readonly lockWaitAttempts?: readonly WorkflowStepAttemptRecord[];
+  readonly locks?: readonly LockRecord[];
+  readonly schedules?: readonly ScheduleRecord[];
+}
+interface WorkflowRecoverySummaryOptions {
+  readonly runs: readonly WorkflowRunRecord[];
+  readonly now: Temporal.Instant;
+  readonly inputs?: WorkflowRecoverySummaryInputs;
+}
+interface WorkflowRecoveryDeadline {
+  readonly timestamp: Temporal.Instant;
+}
+declare function summarizeWorkflowRecovery(options: WorkflowRecoverySummaryOptions): WorkflowRecoverySummary;
+declare function mergeWorkflowRecoveryRunIds(runIdGroups: readonly (readonly string[])[]): readonly string[];
+declare function workflowRecoveryDeadline(ownerId: string | undefined, timestamp: Temporal.Instant | undefined): WorkflowRecoveryDeadline | undefined;
+declare function earliestWorkflowRecoveryDeadline(candidates: readonly (WorkflowRecoveryDeadline | undefined)[]): WorkflowRecoveryDeadline | undefined;
+//#endregion
+export { WorkflowRecoveryDeadline, WorkflowRecoverySummaryInputs, WorkflowRecoverySummaryOptions, earliestWorkflowRecoveryDeadline, mergeWorkflowRecoveryRunIds, summarizeWorkflowRecovery, workflowRecoveryDeadline };

package/dist/engine/recovery.mjs

@@ -0,0 +1,92 @@
+import { createWorkflowRecoveryLockSummaryReducer } from "./summary/recovery-locks.mjs";
+import { createWorkflowRecoveryRunSummaryReducer } from "./summary/recovery-runs.mjs";
+import { createWorkflowRecoveryScheduleSummaryReducer } from "./summary/recovery-schedules.mjs";
+import { createWorkflowRecoveryWaitSummaryReducer } from "./summary/recovery-waits.mjs";
+//#region src/engine/recovery.ts
+function recoveryWaitInputs(inputs) {
+	return {
+		sleepAttempts: inputs.sleepAttempts,
+		messageWaitAttempts: inputs.messageWaitAttempts,
+		childWorkflowAttempts: inputs.childWorkflowAttempts,
+		childRuns: inputs.childRuns,
+		eventsByRunId: inputs.eventsByRunId
+	};
+}
+function recoveryResourceInputs(inputs) {
+	return {
+		lockWaitAttempts: inputs.lockWaitAttempts,
+		locks: inputs.locks,
+		schedules: inputs.schedules
+	};
+}
+function summarizeWorkflowRecovery(options) {
+	const { runs, now, inputs = {} } = options;
+	const waitInputs = recoveryWaitInputs(inputs);
+	const resources = recoveryResourceInputs(inputs);
+	const runReducer = createWorkflowRecoveryRunSummaryReducer(now);
+	for (const run of runs) runReducer.addRun(run);
+	const runSummary = runReducer.finish();
+	const waitReducer = createWorkflowRecoveryWaitSummaryReducer(waitInputs, now);
+	waitReducer.addSleepAttempts(waitInputs.sleepAttempts ?? []);
+	waitReducer.addMessageWaitAttempts(waitInputs.messageWaitAttempts ?? []);
+	waitReducer.addChildWorkflowAttempts(waitInputs.childWorkflowAttempts ?? []);
+	const wait = waitReducer.finish();
+	const lockReducer = createWorkflowRecoveryLockSummaryReducer(runs, now);
+	for (const lockRecord of resources.locks ?? []) lockReducer.addLock(lockRecord);
+	for (const attempt of resources.lockWaitAttempts ?? []) lockReducer.addLockWaitAttempt(attempt);
+	const lock = lockReducer.finish();
+	const scheduleReducer = createWorkflowRecoveryScheduleSummaryReducer(now);
+	for (const scheduleRecord of resources.schedules ?? []) scheduleReducer.addSchedule(scheduleRecord);
+	const schedule = scheduleReducer.finish();
+	const recoverableRunIds = mergeWorkflowRecoveryRunIds([
+		runSummary.recoverableRunIds,
+		wait.sleep.dueRunIds,
+		wait.message.readyRunIds,
+		wait.message.timedOutRunIds,
+		wait.childWorkflow.terminalRunIds,
+		wait.childWorkflow.missingRunIds,
+		wait.childWorkflow.timedOutRunIds
+	]);
+	const summary = {
+		total: runSummary.total,
+		recoverableRunIds,
+		due: runSummary.due,
+		lease: runSummary.lease,
+		retry: runSummary.retry,
+		missingImplementation: runSummary.missingImplementation,
+		failed: runSummary.failed,
+		schedule,
+		lock,
+		wait
+	};
+	const nextRecovery = earliestWorkflowRecoveryDeadline([
+		runSummary.nextAvailable,
+		runSummary.nextLeaseExpires,
+		runSummary.nextRetry,
+		workflowRecoveryDeadline(schedule.nextFireScheduleId, schedule.nextFireAt),
+		workflowRecoveryDeadline(lock.nextExpiringKey, lock.nextExpiresAt),
+		workflowRecoveryDeadline(lock.nextWaitDeadlineRunId, lock.nextWaitDeadlineAt),
+		workflowRecoveryDeadline(wait.sleep.nextWakeRunId, wait.sleep.nextWakeAt),
+		workflowRecoveryDeadline(wait.message.nextTimeoutRunId, wait.message.nextTimeoutAt),
+		workflowRecoveryDeadline(wait.childWorkflow.nextTimeoutRunId, wait.childWorkflow.nextTimeoutAt)
+	]);
+	return {
+		...summary,
+		...nextRecovery === void 0 ? {} : { nextRecoveryAt: nextRecovery.timestamp }
+	};
+}
+function mergeWorkflowRecoveryRunIds(runIdGroups) {
+	return [...new Set(runIdGroups.flat())].sort();
+}
+function workflowRecoveryDeadline(ownerId, timestamp) {
+	return ownerId === void 0 || timestamp === void 0 ? void 0 : { timestamp };
+}
+function earliestWorkflowRecoveryDeadline(candidates) {
+	return candidates.reduce((current, candidate) => {
+		if (candidate === void 0) return current;
+		if (current === void 0) return candidate;
+		return Temporal.Instant.compare(candidate.timestamp, current.timestamp) < 0 ? candidate : current;
+	}, void 0);
+}
+//#endregion
+export { earliestWorkflowRecoveryDeadline, mergeWorkflowRecoveryRunIds, summarizeWorkflowRecovery, workflowRecoveryDeadline };

package/dist/engine/replay.d.mts

@@ -0,0 +1,41 @@
+import { MessageId } from "../types/message-id.mjs";
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowStepRunConfig } from "../types/step.mjs";
+import { WorkflowAttributePatch, WorkflowStepIdentity } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import "../history/mod.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { StorageValue } from "@temelj/storage";
+//#region src/engine/replay.d.ts
+declare function isRunStepTerminalForStartedAttempt(terminal: Extract<EventRecord, {
+  readonly kind: "step_completed" | "step_failed";
+}>, started: Extract<EventRecord, {
+  readonly kind: "step_started";
+}>): boolean;
+declare function requireRecordedDurableStepStarted(identity: WorkflowStepIdentity, started: boolean): void;
+declare function requireRecordedDurableTerminalStarted(identity: WorkflowStepIdentity, hasStartedEventBeforeTerminal: boolean): void;
+declare function requireRunStepReplayTimeoutMatches(identity: WorkflowStepIdentity, started: Extract<EventRecord, {
+  readonly kind: "step_started";
+}> | undefined, config: WorkflowStepRunConfig): void;
+declare function requireMetadataReplayMatches(identity: WorkflowStepIdentity, recorded: Extract<EventRecord, {
+  readonly kind: "metadata_set";
+}>, metadata: StorageValue): void;
+declare function requireAttributesReplayMatches(identity: WorkflowStepIdentity, recorded: Extract<EventRecord, {
+  readonly kind: "attributes_set";
+}>, attributes: WorkflowAttributePatch): void;
+declare function requireMessageSendReplayMatches(identity: WorkflowStepIdentity, started: Extract<EventRecord, {
+  readonly kind: "message_send_started";
+}> | undefined, terminal: Extract<EventRecord, {
+  readonly kind: "message_send_started" | "message_send_completed" | "message_send_failed";
+}>, next: {
+  readonly targetRunId: RunId;
+  readonly messageId: MessageId;
+  readonly payload?: StorageValue;
+  readonly idempotencyKey?: string;
+}): void;
+declare function sleepUntil(environment: WorkflowExecutionEnvironment, name: string, initialUntil: Temporal.Instant, options: {
+  readonly duration?: Temporal.Duration;
+}): Promise<void>;
+declare function recordedStepCompletionTimestamp(identity: WorkflowStepIdentity, value: Temporal.Instant): Temporal.Instant;
+//#endregion
+export { isRunStepTerminalForStartedAttempt, recordedStepCompletionTimestamp, requireAttributesReplayMatches, requireMessageSendReplayMatches, requireMetadataReplayMatches, requireRecordedDurableStepStarted, requireRecordedDurableTerminalStarted, requireRunStepReplayTimeoutMatches, sleepUntil };

package/dist/engine/replay.mjs

@@ -0,0 +1,122 @@
+import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
+import { workflowAttributePatchFromEvent } from "../attributes.mjs";
+import "../errors/mod.mjs";
+import { WorkflowSuspended } from "./state.mjs";
+import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
+import { appendDurableStepStartedEvent, appendDurableStepTerminalEvent } from "./durable-command.mjs";
+import { deepEquals } from "@temelj/value";
+//#region src/engine/replay.ts
+function isRunStepTerminalForStartedAttempt(terminal, started) {
+	return terminal.attempt === started.attempt;
+}
+function requireRecordedDurableStepStarted(identity, started) {
+	if (started) return;
+	WorkflowReplayDivergenceError.diverged(`recorded ${identity.kind} step ${identity.id} has a terminal event without a started event`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+function requireRecordedDurableTerminalStarted(identity, hasStartedEventBeforeTerminal) {
+	requireRecordedDurableStepStarted(identity, hasStartedEventBeforeTerminal);
+}
+function requireRunStepReplayTimeoutMatches(identity, started, config) {
+	if (started === void 0 || started.timeoutAt === void 0 === (config.timeout === void 0)) return;
+	const recordedTimeout = started.timeoutAt === void 0 ? "no timeout" : started.timeoutAt.toString();
+	const replayTimeout = config.timeout === void 0 ? "no timeout" : "a timeout";
+	WorkflowReplayDivergenceError.diverged(`recorded run step ${identity.id} had ${recordedTimeout}, but replay used ${replayTimeout}`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+function requireMetadataReplayMatches(identity, recorded, metadata) {
+	if (deepEquals(recorded.metadata, metadata)) return;
+	WorkflowReplayDivergenceError.diverged(`recorded metadata step ${identity.id} used different metadata`, {
+		expectedStepId: identity.id,
+		actualStepId: recorded.stepId
+	});
+}
+function requireAttributesReplayMatches(identity, recorded, attributes) {
+	if (JSON.stringify(workflowAttributePatchFromEvent(recorded)) === JSON.stringify(attributes)) return;
+	WorkflowReplayDivergenceError.diverged(`recorded attributes step ${identity.id} used different attributes`, {
+		expectedStepId: identity.id,
+		actualStepId: recorded.stepId
+	});
+}
+function requireMessageSendReplayMatches(identity, started, terminal, next) {
+	const recordedTargetRunId = started?.targetRunId ?? terminal.targetRunId;
+	const recordedMessage = started?.messageId ?? terminal.messageId;
+	const recordedPayload = started?.payload;
+	const recordedIdempotencyKey = started?.idempotencyKey;
+	if (recordedTargetRunId === next.targetRunId && recordedMessage === next.messageId && deepEquals(recordedPayload, next.payload) && recordedIdempotencyKey === next.idempotencyKey) return;
+	const message = recordedTargetRunId === next.targetRunId && recordedMessage === next.messageId ? `recorded message-send step ${identity.id} targeted ${recordedTargetRunId} messageId ${recordedMessage} with different payload or idempotency key` : `recorded message-send step ${identity.id} targeted ${recordedTargetRunId} messageId ${recordedMessage}, but replay targeted ${next.targetRunId} messageId ${next.messageId}`;
+	WorkflowReplayDivergenceError.diverged(message, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+async function sleepUntil(environment, name, initialUntil, options) {
+	const { history, now } = environment;
+	const identity = resolveWorkflowCommandIdentity(history, "sleep", name);
+	const started = history.startedSleep(identity.id);
+	const completed = history.completedSleep(identity.id);
+	if (completed !== void 0) {
+		requireRecordedDurableStepStarted(identity, history.hasStartedEventBeforeTerminalEvent(completed));
+		requireSleepReplayMatches(identity, started, initialUntil, options);
+		if (!(completed.timestamp instanceof Temporal.Instant)) WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} has invalid completion timestamp: ` + String(completed.timestamp), {
+			expectedStepId: identity.id,
+			actualStepId: identity.id
+		});
+		return;
+	}
+	const until = started === void 0 ? initialUntil : recordedSleepUntil(identity, started.until);
+	requireSleepReplayMatches(identity, started, initialUntil, options);
+	if (started === void 0) await appendDurableStepStartedEvent(environment, {
+		kind: "sleep_started",
+		timestamp: now(),
+		stepId: identity.id,
+		stepName: identity.name,
+		count: identity.count,
+		until,
+		...options.duration === void 0 ? {} : { duration: options.duration }
+	});
+	if (Temporal.Instant.compare(until, now()) > 0) WorkflowSuspended.until(until);
+	await appendDurableStepTerminalEvent(environment, {
+		kind: "sleep_completed",
+		timestamp: now(),
+		stepId: identity.id,
+		stepName: identity.name
+	});
+}
+function recordedStepCompletionTimestamp(identity, value) {
+	if (value instanceof Temporal.Instant) return value;
+	WorkflowReplayDivergenceError.diverged(`recorded run step ${identity.id} has invalid completion timestamp: ${String(value)}`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+function recordedSleepUntil(identity, value) {
+	if (value instanceof Temporal.Instant) return value;
+	WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} has invalid wake timestamp: ${String(value)}`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+function requireSleepReplayMatches(identity, started, until, options) {
+	if (started === void 0) return;
+	if (started.duration !== void 0 || options.duration !== void 0) {
+		if (started.duration === void 0 || options.duration === void 0) {
+			if (started.duration === options.duration) return;
+		} else if (started.duration.toString() === options.duration.toString()) return;
+		WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} waited for ${String(started.duration)}ms, but replay waited for ${String(options.duration)}ms`, {
+			expectedStepId: identity.id,
+			actualStepId: identity.id
+		});
+	}
+	if (Temporal.Instant.compare(started.until, until) === 0) return;
+	WorkflowReplayDivergenceError.diverged(`recorded sleep step ${identity.id} waited until ${started.until.toString()}, but replay waited until ${until.toString()}`, {
+		expectedStepId: identity.id,
+		actualStepId: identity.id
+	});
+}
+//#endregion
+export { isRunStepTerminalForStartedAttempt, recordedStepCompletionTimestamp, requireAttributesReplayMatches, requireMessageSendReplayMatches, requireMetadataReplayMatches, requireRecordedDurableStepStarted, requireRecordedDurableTerminalStarted, requireRunStepReplayTimeoutMatches, sleepUntil };

package/dist/engine/retry-policy.d.mts

@@ -0,0 +1,4 @@
+//#region src/engine/retry-policy.d.ts
+declare const MAX_CONCURRENT_RUN_UPDATE_ATTEMPTS = 16;
+//#endregion
+export { MAX_CONCURRENT_RUN_UPDATE_ATTEMPTS };

package/dist/engine/retry-policy.mjs

@@ -0,0 +1,4 @@
+//#region src/engine/retry-policy.ts
+const MAX_CONCURRENT_RUN_UPDATE_ATTEMPTS = 16;
+//#endregion
+export { MAX_CONCURRENT_RUN_UPDATE_ATTEMPTS };

package/dist/engine/retry.d.mts

@@ -0,0 +1,23 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowMissingImplementationRetryConfig, WorkflowMissingImplementationRetryDefaults, WorkflowResolvedMissingImplementationRetryConfig, WorkflowResolvedRetryConfig, WorkflowResolvedRetryDefaults, WorkflowResolvedStepRetryConfig, WorkflowRetryConfig } from "../types/retry.mjs";
+import { WorkflowStepRunWorkflowOptions } from "../types/step.mjs";
+import "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowHistory } from "../history/mod.mjs";
+//#region src/engine/retry.d.ts
+interface WorkflowEngineRetryLimits {
+  readonly maximumEventHistoryEvents?: number;
+}
+/** Resolves retry options and merges them with defaults used by workflow or step execution. */
+declare function resolveWorkflowRetryConfig(config: WorkflowRetryConfig | undefined, defaults: WorkflowResolvedRetryDefaults, label: string): WorkflowResolvedRetryConfig;
+/** Resolves missing-implementation retry options and merges them with worker defaults. */
+declare function resolveMissingImplementationRetryConfig(config: WorkflowMissingImplementationRetryConfig | undefined, defaults: WorkflowMissingImplementationRetryDefaults, label: string): WorkflowResolvedMissingImplementationRetryConfig;
+declare function resolveChildWorkflowRetryConfig(options: WorkflowStepRunWorkflowOptions | undefined): WorkflowResolvedStepRetryConfig;
+declare function shouldRetryWorkflowAttempt(retry: WorkflowResolvedRetryConfig, failedAttempt: number): boolean;
+declare function nextWorkflowRetryAttempt(failedAttempt: number): number;
+declare function enforceStepAttemptBudget(runId: RunId, history: WorkflowHistory, maximumStepAttemptsPerRun: number): void;
+declare function enforceWorkflowEventHistoryNextLimit(events: readonly EventRecord[], limits: WorkflowEngineRetryLimits): void;
+declare function nextRetryAt(failedAt: Temporal.Instant, retry: WorkflowResolvedRetryConfig, failedAttempt: number, label: string): Temporal.Instant | undefined;
+declare function retryClassificationRetryAt(failedAt: Temporal.Instant, error: unknown, label: string): Temporal.Instant | undefined;
+//#endregion
+export { enforceStepAttemptBudget, enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveChildWorkflowRetryConfig, resolveMissingImplementationRetryConfig, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt };

package/dist/engine/retry.mjs

@@ -0,0 +1,75 @@
+import { WorkflowOptionsError } from "../errors/base.mjs";
+import { WorkflowDurationError, WorkflowRetryableError, WorkflowSerializationError } from "../errors/failures.mjs";
+import { durationAmount, isPositiveSafeInteger, nextPositiveSafeInteger, resolveSafeRetryDelay } from "../utility.mjs";
+import { WorkflowStepAttemptLimitError } from "../errors/step.mjs";
+import "../errors/mod.mjs";
+//#region src/engine/retry.ts
+const DEFAULT_STEP_RETRY_CONFIG = {
+	maximumAttempts: 10,
+	backoffCoefficient: 2
+};
+/** Resolves retry options and merges them with defaults used by workflow or step execution. */
+function resolveWorkflowRetryConfig(config, defaults, label) {
+	const input = config ?? {};
+	if (input.initialInterval !== void 0 && input.maximumInterval !== void 0 && Temporal.Duration.compare(input.maximumInterval, input.initialInterval) < 0) WorkflowOptionsError.retryMaximumIntervalTooSmall(label);
+	return {
+		maximumAttempts: input.maximumAttempts ?? defaults.maximumAttempts,
+		...input.initialInterval === void 0 ? {} : { initialInterval: input.initialInterval },
+		backoffCoefficient: input.backoffCoefficient ?? defaults.backoffCoefficient,
+		...input.maximumInterval === void 0 ? {} : { maximumInterval: input.maximumInterval }
+	};
+}
+/** Resolves missing-implementation retry options and merges them with worker defaults. */
+function resolveMissingImplementationRetryConfig(config, defaults, label) {
+	const input = config === void 0 ? {} : config;
+	const initialInterval = input.initialInterval ?? defaults.initialInterval;
+	const maximumInterval = input.maximumInterval;
+	if (maximumInterval !== void 0 && Temporal.Duration.compare(maximumInterval, initialInterval) < 0) WorkflowOptionsError.retryMaximumIntervalTooSmall(label);
+	return {
+		initialInterval,
+		backoffCoefficient: input.backoffCoefficient ?? defaults.backoffCoefficient,
+		maximumAttempts: input.maximumAttempts ?? defaults.maximumAttempts,
+		...maximumInterval === void 0 ? {} : { maximumInterval }
+	};
+}
+function resolveChildWorkflowRetryConfig(options) {
+	if (options?.retry === void 0) return {
+		maximumAttempts: 1,
+		backoffCoefficient: DEFAULT_STEP_RETRY_CONFIG.backoffCoefficient
+	};
+	return resolveWorkflowRetryConfig(options.retry, DEFAULT_STEP_RETRY_CONFIG, "Workflow step retry");
+}
+function shouldRetryWorkflowAttempt(retry, failedAttempt) {
+	return retry.maximumAttempts === 0 || failedAttempt < retry.maximumAttempts;
+}
+function nextWorkflowRetryAttempt(failedAttempt) {
+	const nextAttempt = nextPositiveSafeInteger(failedAttempt);
+	if (nextAttempt === void 0) WorkflowOptionsError.positiveSafeInteger("Workflow retry next attempt");
+	return nextAttempt;
+}
+function enforceStepAttemptBudget(runId, history, maximumStepAttemptsPerRun) {
+	if (history.totalStartedStepCount() >= maximumStepAttemptsPerRun) WorkflowStepAttemptLimitError.exceeded(runId, maximumStepAttemptsPerRun);
+}
+function enforceWorkflowEventHistoryNextLimit(events, limits) {
+	if (limits.maximumEventHistoryEvents !== void 0 && events.length >= limits.maximumEventHistoryEvents) WorkflowSerializationError.notSerializable("workflow event history", `event count would exceed maximumEventHistoryEvents ${limits.maximumEventHistoryEvents}`);
+}
+function nextRetryAt(failedAt, retry, failedAttempt, label) {
+	if (retry.initialInterval === void 0) return;
+	if (!isPositiveSafeInteger(failedAttempt)) WorkflowOptionsError.positiveSafeInteger(`${label} attempt`);
+	const exponentialDelay = durationAmount(retry.initialInterval, label) * retry.backoffCoefficient ** (failedAttempt - 1);
+	const cappedDelay = retry.maximumInterval === void 0 ? exponentialDelay : Math.min(exponentialDelay, durationAmount(retry.maximumInterval, label));
+	return failedAt.add(Temporal.Duration.from({ milliseconds: resolveSafeRetryDelay(cappedDelay, label) }));
+}
+function retryClassificationRetryAt(failedAt, error, label) {
+	if (!(error instanceof WorkflowRetryableError)) return;
+	if (error.retryAt !== void 0) {
+		if (!(error.retryAt instanceof Temporal.Instant)) WorkflowDurationError.retryAtInstant(label);
+		return error.retryAt;
+	}
+	if (error.retryDelay !== void 0) {
+		const retryDelay = durationAmount(error.retryDelay, label);
+		return failedAt.add(Temporal.Duration.from({ milliseconds: resolveSafeRetryDelay(retryDelay, label) }));
+	}
+}
+//#endregion
+export { enforceStepAttemptBudget, enforceWorkflowEventHistoryNextLimit, nextRetryAt, nextWorkflowRetryAttempt, resolveChildWorkflowRetryConfig, resolveMissingImplementationRetryConfig, resolveWorkflowRetryConfig, retryClassificationRetryAt, shouldRetryWorkflowAttempt };

package/dist/engine/run-data.d.mts

@@ -0,0 +1,9 @@
+import { WorkflowStepRunDataApi } from "../types/step.mjs";
+import { WorkflowAttributePatch } from "../types/run.mjs";
+import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+//#region src/engine/run-data.d.ts
+declare function createWorkflowRunDataApi(environment: WorkflowExecutionEnvironment): WorkflowStepRunDataApi;
+declare function setWorkflowRunMetadata(environment: WorkflowExecutionEnvironment, commandId: string, metadata: unknown): Promise<void>;
+declare function setWorkflowRunAttributes(environment: WorkflowExecutionEnvironment, commandId: string, attributes: WorkflowAttributePatch): Promise<void>;
+//#endregion
+export { createWorkflowRunDataApi, setWorkflowRunAttributes, setWorkflowRunMetadata };