@temelj/workflow 0.0.0-alpha.1

package/dist/store/materialization.mjs

@@ -0,0 +1,127 @@
+import { WorkflowStateError } from "../errors/base.mjs";
+import { makeWorkflowStepAttemptKey } from "../history/attempt-key.mjs";
+import { omitUndefined } from "../collection.mjs";
+import { getWorkflowEventStepAttemptKey } from "../events/descriptors.mjs";
+import { applyWorkflowStepAttemptEvent } from "../history/projection.mjs";
+import "../history/mod.mjs";
+import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
+import { makeStepAttemptKey } from "../store-keys.mjs";
+import { toStorageValue } from "./storage-value.mjs";
+import { parseStoredWorkflowStepAttemptRecord } from "./validation.mjs";
+import { rollbackAppendedEventIfCurrent } from "./event-history.mjs";
+import { createWorkflowStepAttempts } from "../history/step-attempts.mjs";
+import { requireReadableStoredWorkflowRun } from "./run.mjs";
+//#region src/store/materialization.ts
+const MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS = 16;
+const WORKFLOW_MATERIALIZED_STEP_DESCRIPTORS = {
+	run: { identityFields: [] },
+	sleep: { identityFields: ["until"] },
+	workflow: { identityFields: [
+		"childRunId",
+		"workflowName",
+		"workflowVersion",
+		"cancellation"
+	] },
+	"message-send": { identityFields: ["targetRunId", "messageId"] },
+	"message-wait": { identityFields: ["messageId"] },
+	stream: { identityFields: [] },
+	deterministic: { identityFields: [] }
+};
+async function materializeStepAttempt(storage, namespace, runId, event) {
+	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+	if (storageKey === void 0) return;
+	await materializeStepAttemptIfCurrent(storage, runId, storageKey, (current) => applyWorkflowStepAttemptEvent(runId, event, current));
+}
+async function materializeStepAttemptForAppendOutcome(storage, namespace, runId, event, outcome) {
+	try {
+		await materializeStepAttempt(storage, namespace, runId, event);
+	} catch (error) {
+		if (outcome.status === "appended") await rollbackAppendedEventIfCurrent(storage, namespace, runId, outcome.events, outcome.previousEventHistory);
+		throw error;
+	}
+}
+function getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event) {
+	let attemptKey;
+	try {
+		attemptKey = getWorkflowEventStepAttemptKey(event);
+	} catch {
+		attemptKey = void 0;
+	}
+	return attemptKey === void 0 ? void 0 : makeStepAttemptKey(namespace, runId, attemptKey);
+}
+function createWorkflowStepAttemptMaterializationUpdate(namespace, runId, event, current) {
+	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+	if (storageKey === void 0) return;
+	const next = applyWorkflowStepAttemptEvent(runId, event, current);
+	return {
+		storageKey,
+		...next === void 0 ? {} : { next },
+		shouldStore: next !== void 0 && shouldStoreStepAttempt(current, next)
+	};
+}
+async function createWorkflowStepAttemptMaterializationStoragePlan(storage, namespace, runId, event) {
+	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+	if (storageKey === void 0) return { materializes: false };
+	const { raw, current } = await readStoredWorkflowStepAttempt(storage, storageKey);
+	const materialization = createWorkflowStepAttemptMaterializationUpdate(namespace, runId, event, current);
+	return {
+		materializes: true,
+		storageKey,
+		...current === void 0 ? {} : { current },
+		...materialization?.shouldStore === true && materialization.next !== void 0 ? { item: {
+			key: materialization.storageKey,
+			expected: raw,
+			value: toStorageValue(omitUndefined(materialization.next))
+		} } : {}
+	};
+}
+async function reconcileStepAttempts(storage, namespace, runId, events) {
+	const attempts = createWorkflowStepAttempts(runId, events);
+	await requireReadableStoredWorkflowRun(storage, namespace, runId);
+	await Promise.all(attempts.map((attempt) => materializeStepAttemptIfCurrent(storage, runId, makeStepAttemptKey(namespace, runId, makeWorkflowStepAttemptKey(attempt.stepId, attempt.attempt)), () => attempt, { repairStatusMismatch: true })));
+	return attempts;
+}
+async function materializeStepAttemptIfCurrent(storage, runId, storageKey, createNext, options = {}) {
+	if (!supportsWorkflowConditionalWrite(storage)) {
+		const { current } = await readStoredWorkflowStepAttempt(storage, storageKey);
+		const next = createNext(current);
+		if (next !== void 0 && shouldStoreStepAttempt(current, next, options)) await storage.set(storageKey, toStorageValue(omitUndefined(next)));
+		return;
+	}
+	for (let attempt = 0; attempt < MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS; attempt++) {
+		const { raw, current } = await readStoredWorkflowStepAttempt(storage, storageKey);
+		const next = createNext(current);
+		if (next === void 0 || !shouldStoreStepAttempt(current, next, options)) return;
+		if (await storage.compareAndSet(storageKey, raw, toStorageValue(omitUndefined(next)))) return;
+	}
+	WorkflowStateError.failedStepAttemptMaterialization(runId, MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS);
+}
+async function readStoredWorkflowStepAttempt(storage, storageKey) {
+	const raw = await storage.get(storageKey);
+	return {
+		raw,
+		current: parseStoredWorkflowStepAttemptRecord(raw)
+	};
+}
+function shouldStoreStepAttempt(current, next, options = {}) {
+	if (current === void 0) return true;
+	if (!isSameStepAttemptIdentity(current, next)) return true;
+	if (current.status === "abandoned" !== (next.status === "abandoned")) return true;
+	if (options.repairStatusMismatch === true && current.status !== next.status) return true;
+	const currentTimestamp = current.finishedAt ?? current.startedAt;
+	const nextTimestamp = next.finishedAt ?? next.startedAt;
+	if (currentTimestamp === void 0) return true;
+	if (nextTimestamp === void 0) return false;
+	if (Temporal.Instant.compare(currentTimestamp, nextTimestamp) > 0) return false;
+	if (Temporal.Instant.compare(currentTimestamp, nextTimestamp) < 0) return true;
+	return (next.status === "running" ? 0 : next.status === "abandoned" || next.status === "failed" || next.status === "completed" ? 1 : 0) >= (current.status === "running" ? 0 : current.status === "abandoned" || current.status === "failed" || current.status === "completed" ? 1 : 0);
+}
+function isSameStepAttemptIdentity(current, next) {
+	if (!(current.runId === next.runId && current.stepId === next.stepId && current.stepName === next.stepName && current.kind === next.kind && current.attempt === next.attempt && current.count === next.count)) return false;
+	return isSameMaterializedStepAttemptFields(current, next, WORKFLOW_MATERIALIZED_STEP_DESCRIPTORS[current.kind].identityFields);
+}
+function isSameMaterializedStepAttemptFields(current, next, fields) {
+	return fields.every((field) => current[field] === next[field]);
+}
+//#endregion
+export { createWorkflowStepAttemptMaterializationStoragePlan, isSameStepAttemptIdentity, materializeStepAttemptForAppendOutcome, materializeStepAttemptIfCurrent, reconcileStepAttempts, shouldStoreStepAttempt };

package/dist/store/message-index.d.mts

@@ -0,0 +1,21 @@
+import { RunId } from "../types/run-id.mjs";
+import "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowMessageIdempotencyIndex, WorkflowStorage } from "../types/store.mjs";
+import { WorkflowEventAppendSuccessOutcome } from "./event-append.mjs";
+//#region src/store/message-index.d.ts
+interface WorkflowDuplicateMessageAppendOutcome {
+  readonly status: "duplicate";
+  readonly events: readonly EventRecord[];
+}
+declare function duplicateMessageAppendOutcome(runId: RunId, events: readonly EventRecord[], event: EventRecord): WorkflowDuplicateMessageAppendOutcome | undefined;
+declare function projectMessageIdempotencyIndexForAppendOutcome(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, outcome: WorkflowEventAppendSuccessOutcome): Promise<readonly EventRecord[]>;
+declare function reconcileMessageIdempotencyIndexes(storage: WorkflowStorage, namespace: string, runId: RunId, events: readonly EventRecord[]): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
+declare function repairMessageIdempotencyIndexes(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
+declare function hasMessageIdempotencyKey(storage: WorkflowStorage, namespace: string, runId: RunId, idempotencyKey: string): Promise<boolean>;
+declare function messageIdempotencyIndexValuesFromEvents(events: readonly EventRecord[], runId: RunId): readonly {
+  readonly idempotencyKey: string;
+  readonly value: WorkflowMessageIdempotencyIndex;
+}[];
+//#endregion
+export { WorkflowDuplicateMessageAppendOutcome, duplicateMessageAppendOutcome, hasMessageIdempotencyKey, messageIdempotencyIndexValuesFromEvents, projectMessageIdempotencyIndexForAppendOutcome, reconcileMessageIdempotencyIndexes, repairMessageIdempotencyIndexes };

package/dist/store/message-index.mjs

@@ -0,0 +1,121 @@
+import { WorkflowMessageIdempotencyConflictError } from "../errors/message.mjs";
+import "../errors/mod.mjs";
+import { WorkflowHistory } from "../history/mod.mjs";
+import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
+import { makeEventsKey, makeMessageIdempotencyKey } from "../store-keys.mjs";
+import { isSameWorkflowStorageValue } from "./revision.mjs";
+import { toStorageValue } from "./storage-value.mjs";
+import { isSameMessageIdempotencyIndex } from "./validation.mjs";
+import { getStoredEventHistory, rollbackAppendedEventIfCurrent } from "./event-history.mjs";
+import { requireReadableStoredWorkflowRun } from "./run.mjs";
+//#region src/store/message-index.ts
+function duplicateMessageAppendOutcome(runId, events, event) {
+	if (!isMessageIdempotencyEvent(event)) return;
+	const existing = new WorkflowHistory(events).messageByIdempotencyKey(event.idempotencyKey);
+	if (existing === void 0) return;
+	requireDuplicateMessageEventMatches(runId, existing, event);
+	return {
+		status: "duplicate",
+		events
+	};
+}
+function isMessageIdempotencyEvent(event) {
+	return event.kind === "message_sent" && event.idempotencyKey !== void 0;
+}
+function requireDuplicateMessageEventMatches(runId, existing, event) {
+	if (existing.messageId === event.messageId && isSameWorkflowStorageValue(existing.payload, event.payload)) return;
+	WorkflowMessageIdempotencyConflictError.conflict({
+		runId,
+		messageId: existing.messageId,
+		idempotencyKey: event.idempotencyKey
+	});
+}
+async function indexMessageIdempotencyKey(storage, namespace, runId, event, events) {
+	if (event.kind !== "message_sent" || event.idempotencyKey === void 0) return;
+	await requireReadableStoredWorkflowRun(storage, namespace, runId);
+	const indexedEvent = indexableMessageEventByIdempotencyKey(new WorkflowHistory(events), event.idempotencyKey);
+	if (indexedEvent === void 0) return;
+	const key = makeMessageIdempotencyKey(namespace, runId, event.idempotencyKey);
+	const value = {
+		runId,
+		messageId: indexedEvent.messageId,
+		timestamp: indexedEvent.timestamp
+	};
+	if (!supportsWorkflowConditionalWrite(storage)) {
+		const current = await storage.get(key);
+		if (current !== void 0) {
+			if (isSameMessageIdempotencyIndex(current, value)) return;
+			WorkflowMessageIdempotencyConflictError.conflict({
+				runId,
+				messageId: indexedEvent.messageId,
+				idempotencyKey: event.idempotencyKey
+			});
+		}
+		await storage.set(key, toStorageValue(value));
+		return;
+	}
+	if (await storage.compareAndSet(key, void 0, toStorageValue(value))) return;
+	if (isSameMessageIdempotencyIndex(await storage.get(key), value)) return;
+	WorkflowMessageIdempotencyConflictError.conflict({
+		runId,
+		messageId: indexedEvent.messageId,
+		idempotencyKey: event.idempotencyKey
+	});
+}
+async function projectMessageIdempotencyIndexForAppendOutcome(storage, namespace, runId, event, outcome) {
+	try {
+		await indexMessageIdempotencyKey(storage, namespace, runId, event, outcome.events);
+	} catch (error) {
+		if (outcome.status === "appended") await rollbackAppendedEventIfCurrent(storage, namespace, runId, outcome.events, outcome.previousEventHistory);
+		throw error;
+	}
+	return outcome.events;
+}
+async function reconcileMessageIdempotencyIndexes(storage, namespace, runId, events) {
+	await requireReadableStoredWorkflowRun(storage, namespace, runId);
+	const indexes = messageIdempotencyIndexValuesFromEvents(events, runId);
+	await Promise.all(indexes.map(async ({ idempotencyKey, value }) => {
+		await storeMessageIdempotencyIndex(storage, namespace, runId, idempotencyKey, value);
+	}));
+	return indexes.map((index) => index.value);
+}
+async function repairMessageIdempotencyIndexes(storage, namespace, runId) {
+	await requireReadableStoredWorkflowRun(storage, namespace, runId);
+	return await reconcileMessageIdempotencyIndexes(storage, namespace, runId, (await getStoredEventHistory(storage, makeEventsKey(namespace, runId))).events);
+}
+async function hasMessageIdempotencyKey(storage, namespace, runId, idempotencyKey) {
+	return await storage.get(makeMessageIdempotencyKey(namespace, runId, idempotencyKey)) !== void 0;
+}
+function indexableMessageEventByIdempotencyKey(history, idempotencyKey) {
+	const event = history.messageByIdempotencyKey(idempotencyKey);
+	return event !== void 0 && isIndexableMessageIdempotencyEvent(event) ? event : void 0;
+}
+function messageIdempotencyIndexValuesFromEvents(events, runId) {
+	return new WorkflowHistory(events).latestMessagesByIdempotencyKey().filter(isIndexableMessageIdempotencyEvent).map((event) => ({
+		idempotencyKey: event.idempotencyKey,
+		value: {
+			runId,
+			messageId: event.messageId,
+			timestamp: event.timestamp
+		}
+	}));
+}
+function isIndexableMessageIdempotencyEvent(event) {
+	return event.kind === "message_sent" && event.idempotencyKey !== void 0 && typeof event.messageId === "string" && event.messageId.trim() !== "";
+}
+async function storeMessageIdempotencyIndex(storage, namespace, runId, idempotencyKey, value) {
+	const key = makeMessageIdempotencyKey(namespace, runId, idempotencyKey);
+	const current = await storage.get(key);
+	if (isSameMessageIdempotencyIndex(current, value)) return;
+	if (!supportsWorkflowConditionalWrite(storage)) {
+		await storage.set(key, toStorageValue(value));
+		return;
+	}
+	if (!await storage.compareAndSet(key, current, toStorageValue(value))) WorkflowMessageIdempotencyConflictError.conflict({
+		runId,
+		messageId: value.messageId,
+		idempotencyKey
+	});
+}
+//#endregion
+export { duplicateMessageAppendOutcome, hasMessageIdempotencyKey, messageIdempotencyIndexValuesFromEvents, projectMessageIdempotencyIndexForAppendOutcome, reconcileMessageIdempotencyIndexes, repairMessageIdempotencyIndexes };

package/dist/store/mod.d.mts

@@ -0,0 +1,5 @@
+import { CreateWorkflowStoreOptions, WorkflowClaimRunOptions, WorkflowCleanupIndexKey, WorkflowCleanupIndexValue, WorkflowCleanupRepository, WorkflowConditionalEventAppender, WorkflowEventAppender, WorkflowEventHistoryChangeWaitOptions, WorkflowEventHistoryWatcher, WorkflowEventLog, WorkflowEventReader, WorkflowExtendRunLeaseOptions, WorkflowIdempotencyIndex, WorkflowIdempotencyKeyOptions, WorkflowLockConditionalWriterRepository, WorkflowLockListerRepository, WorkflowLockReaderRepository, WorkflowLockRepository, WorkflowMessageIdempotencyIndex, WorkflowMessageIdempotencyIndexLookup, WorkflowMessageIdempotencyRepairModel, WorkflowReleaseRunLeaseOptions, WorkflowRunConditionalWriterRepository, WorkflowRunCreationRepository, WorkflowRunLeaseRepository, WorkflowRunListerRepository, WorkflowRunQueryRepository, WorkflowRunReaderRepository, WorkflowRunRepository, WorkflowRunUnconditionalWriterRepository, WorkflowRunWriterRepository, WorkflowScheduleConditionalWriterRepository, WorkflowScheduleCreationRepository, WorkflowScheduleListerRepository, WorkflowScheduleQueryRepository, WorkflowScheduleReaderRepository, WorkflowScheduleRepository, WorkflowStepAttemptLookup, WorkflowStepAttemptReadModel, WorkflowStorage, WorkflowStoreCapabilities, WorkflowStoreCapabilitiesSource, WorkflowStoreMetadata, WorkflowStoreNamespace, WorkflowStoreStorageContext } from "../types/store.mjs";
+import { getWorkflowStoreCapabilities } from "./capabilities.mjs";
+import { WorkflowStore, createWorkflowStore } from "./create.mjs";
+import { workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema } from "./schema.mjs";
+export { type CreateWorkflowStoreOptions, type WorkflowClaimRunOptions, type WorkflowCleanupIndexKey, type WorkflowCleanupIndexValue, type WorkflowCleanupRepository, type WorkflowConditionalEventAppender, type WorkflowEventAppender, type WorkflowEventHistoryChangeWaitOptions, type WorkflowEventHistoryWatcher, type WorkflowEventLog, type WorkflowEventReader, type WorkflowExtendRunLeaseOptions, type WorkflowIdempotencyIndex, type WorkflowIdempotencyKeyOptions, type WorkflowLockConditionalWriterRepository, type WorkflowLockListerRepository, type WorkflowLockReaderRepository, type WorkflowLockRepository, type WorkflowMessageIdempotencyIndex, type WorkflowMessageIdempotencyIndexLookup, type WorkflowMessageIdempotencyRepairModel, type WorkflowReleaseRunLeaseOptions, type WorkflowRunConditionalWriterRepository, type WorkflowRunCreationRepository, type WorkflowRunLeaseRepository, type WorkflowRunListerRepository, type WorkflowRunQueryRepository, type WorkflowRunReaderRepository, type WorkflowRunRepository, type WorkflowRunUnconditionalWriterRepository, type WorkflowRunWriterRepository, type WorkflowScheduleConditionalWriterRepository, type WorkflowScheduleCreationRepository, type WorkflowScheduleListerRepository, type WorkflowScheduleQueryRepository, type WorkflowScheduleReaderRepository, type WorkflowScheduleRepository, type WorkflowStepAttemptLookup, type WorkflowStepAttemptReadModel, type WorkflowStorage, WorkflowStore, type WorkflowStoreCapabilities, type WorkflowStoreCapabilitiesSource, type WorkflowStoreMetadata, type WorkflowStoreNamespace, type WorkflowStoreStorageContext, createWorkflowStore, getWorkflowStoreCapabilities, workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema };

package/dist/store/mod.mjs

@@ -0,0 +1,4 @@
+import { getWorkflowStoreCapabilities } from "./capabilities.mjs";
+import { workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema } from "./schema.mjs";
+import { WorkflowStore, createWorkflowStore } from "./create.mjs";
+export { WorkflowStore, createWorkflowStore, getWorkflowStoreCapabilities, workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema };

package/dist/store/query.d.mts

@@ -0,0 +1,24 @@
+import { RunId } from "../types/run-id.mjs";
+import { ListSchedulesOptions, ScheduleRecord } from "../types/schedule.mjs";
+import { WorkflowListRunsOptions } from "../types/run-list.mjs";
+import { WorkflowListStepAttemptsOptions, WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { WorkflowEventReader, WorkflowRunReaderRepository, WorkflowStorage } from "../types/store.mjs";
+//#region src/store/query.d.ts
+type WorkflowStepAttemptQueryStore = WorkflowRunReaderRepository & WorkflowEventReader;
+declare function queryWorkflowRuns(storage: WorkflowStorage, namespace: string, options: WorkflowListRunsOptions | undefined, query: {
+  readonly label: string;
+  readonly sort: boolean;
+}): Promise<readonly WorkflowRunRecord[]>;
+declare function queryWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStepAttemptQueryStore, runId: RunId, options: WorkflowListStepAttemptsOptions | undefined, _query: {
+  readonly label: string;
+}): Promise<readonly WorkflowStepAttemptRecord[]>;
+declare function querySchedules(storage: WorkflowStorage, namespace: string, options: ListSchedulesOptions | undefined, _query: {
+  readonly label: string;
+}): Promise<readonly ScheduleRecord[]>;
+declare function getRequiredStoreRun(store: WorkflowRunReaderRepository, runId: RunId): Promise<WorkflowRunRecord>;
+declare function matchesWorkflowRunListOptions(run: WorkflowRunRecord, options: WorkflowListRunsOptions | undefined): boolean;
+declare function matchesWorkflowStepAttemptListOptions(attempt: WorkflowStepAttemptRecord, options: WorkflowListStepAttemptsOptions | undefined): boolean;
+declare function matchesScheduleListOptions(schedule: ScheduleRecord, options: ListSchedulesOptions | undefined): boolean;
+//#endregion
+export { getRequiredStoreRun, matchesScheduleListOptions, matchesWorkflowRunListOptions, matchesWorkflowStepAttemptListOptions, querySchedules, queryWorkflowRuns, queryWorkflowStepAttempts };

package/dist/store/query.mjs

@@ -0,0 +1,82 @@
+import { WorkflowRunNotFoundError } from "../errors/run.mjs";
+import { matchesOptionalValue, uniqueBy } from "../collection.mjs";
+import "../errors/mod.mjs";
+import { compareOptionalTimestamps, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange } from "../temporal.mjs";
+import { makeRunKeyPrefix, makeScheduleKeyPrefix } from "../store-keys.mjs";
+import { isListableWorkflowRunRecord, isReadableScheduleRecord } from "./validation.mjs";
+import { reconcileStepAttempts } from "./materialization.mjs";
+//#region src/store/query.ts
+async function queryWorkflowRuns(storage, namespace, options, query) {
+	const uniqueRuns = uniqueBy((await storage.entries({ prefix: makeRunKeyPrefix(namespace) })).map((entry) => entry.value).filter((run) => isListableWorkflowRunRecord(run, namespace)).filter((run) => matchesWorkflowRunListOptions(run, options)), (run) => run.id);
+	if (!query.sort) return uniqueRuns;
+	return [...uniqueRuns].sort(compareWorkflowRunsForQuery);
+}
+async function queryWorkflowStepAttempts(storage, namespace, store, runId, options, _query) {
+	await getRequiredStoreRun(store, runId);
+	return (await reconcileStepAttempts(storage, namespace, runId, await store.getEvents(runId))).filter((attempt) => matchesWorkflowStepAttemptListOptions(attempt, options));
+}
+async function querySchedules(storage, namespace, options, _query) {
+	return uniqueBy((await storage.entries({ prefix: makeScheduleKeyPrefix(namespace) })).map((entry) => entry.value).filter((schedule) => isReadableScheduleRecord(schedule, namespace)).filter((schedule) => matchesScheduleListOptions(schedule, options)).sort(compareSchedulesForQuery), (schedule) => schedule.id);
+}
+function compareWorkflowRunsForQuery(left, right) {
+	const createdOrder = compareOptionalTimestamps(left.createdAt, right.createdAt);
+	if (createdOrder !== 0) return createdOrder;
+	return left.id.localeCompare(right.id);
+}
+function compareSchedulesForQuery(left, right) {
+	return Temporal.Instant.compare(left.nextFireAt, right.nextFireAt) || Temporal.Instant.compare(left.createdAt, right.createdAt) || left.id.localeCompare(right.id);
+}
+async function getRequiredStoreRun(store, runId) {
+	const run = await store.getRun(runId);
+	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
+	return run;
+}
+function matchesWorkflowRunListOptions(run, options) {
+	if (options?.status !== void 0 && !matchesOptionalValue(run.status, options.status)) return false;
+	if (options?.workflowName !== void 0 && run.workflowName !== options.workflowName) return false;
+	if (options?.workflowVersion !== void 0 && run.workflowVersion !== options.workflowVersion) return false;
+	if (options?.idempotencyKey !== void 0 && run.idempotencyKey !== options.idempotencyKey) return false;
+	if (options?.workerId !== void 0 && run.workerId !== options.workerId) return false;
+	if (options?.parentRunId !== void 0 && run.parentRunId !== options.parentRunId) return false;
+	if (options?.parentStepId !== void 0 && run.parentStepId !== options.parentStepId) return false;
+	if (options?.parentStepName !== void 0 && run.parentStepName !== options.parentStepName) return false;
+	if (options?.parentStepAttempt !== void 0 && run.parentStepAttempt !== options.parentStepAttempt) return false;
+	if (options?.lastTransitionReason !== void 0 && !matchesOptionalValue(run.lastTransitionReason, options.lastTransitionReason)) return false;
+	if (options?.retryReason !== void 0 && (run.retryReason === void 0 || !matchesOptionalValue(run.retryReason, options.retryReason))) return false;
+	if (!matchesRunAttributeFilters(run, options)) return false;
+	return matchesTimestampRange(run.createdAt, options?.createdAtFrom, options?.createdAtTo) && matchesTimestampRange(run.updatedAt, options?.updatedAtFrom, options?.updatedAtTo) && matchesOptionalTimestampRange(run.finishedAt, options?.finishedAtFrom, options?.finishedAtTo) && matchesOptionalTimestampRange(run.startedAt, options?.startedAtFrom, options?.startedAtTo) && matchesOptionalTimestampRange(run.availableAt, options?.availableAtFrom, options?.availableAtTo) && matchesOptionalTimestampRange(run.leaseExpiresAt, options?.leaseExpiresAtFrom, options?.leaseExpiresAtTo) && matchesOptionalTimestampRange(run.retryAt, options?.retryAtFrom, options?.retryAtTo);
+}
+function matchesWorkflowStepAttemptListOptions(attempt, options) {
+	if (options?.status !== void 0 && !matchesOptionalValue(attempt.status, options.status)) return false;
+	if (options?.kind !== void 0 && !matchesOptionalValue(attempt.kind, options.kind)) return false;
+	if (options?.stepId !== void 0 && attempt.stepId !== options.stepId) return false;
+	if (options?.stepName !== void 0 && attempt.stepName !== options.stepName) return false;
+	if (options?.attempt !== void 0 && attempt.attempt !== options.attempt) return false;
+	if (options?.childRunId !== void 0 && attempt.childRunId !== options.childRunId) return false;
+	if (options?.workflowName !== void 0 && attempt.workflowName !== options.workflowName) return false;
+	if (options?.workflowVersion !== void 0 && attempt.workflowVersion !== options.workflowVersion) return false;
+	if (options?.messageId !== void 0 && attempt.messageId !== options.messageId) return false;
+	if (options?.targetRunId !== void 0 && attempt.targetRunId !== options.targetRunId) return false;
+	return matchesTimestampRange(attempt.createdAt, options?.createdAtFrom, options?.createdAtTo) && matchesTimestampRange(attempt.startedAt, options?.startedAtFrom, options?.startedAtTo) && matchesOptionalTimestampRange(attempt.finishedAt, options?.finishedAtFrom, options?.finishedAtTo) && matchesOptionalTimestampRange(attempt.until, options?.untilFrom, options?.untilTo) && matchesOptionalDurationRange(attempt.duration, options?.durationFrom, options?.durationTo) && matchesOptionalTimestampRange(attempt.timeoutAt, options?.timeoutAtFrom, options?.timeoutAtTo) && matchesOptionalTimestampRange(attempt.messageTimestamp, options?.messageTimestampFrom, options?.messageTimestampTo);
+}
+function matchesScheduleListOptions(schedule, options) {
+	if (options?.status !== void 0 && !matchesOptionalValue(schedule.status, options.status)) return false;
+	if (options?.workflowName !== void 0 && schedule.workflowName !== options.workflowName) return false;
+	if (options?.workflowVersion !== void 0 && schedule.workflowVersion !== options.workflowVersion) return false;
+	return true;
+}
+function matchesRunAttributeFilters(run, options) {
+	if (options === void 0) return true;
+	if (options.attributes !== void 0) {
+		for (const [key, value] of Object.entries(options.attributes)) if (!Object.is(run.attributes?.[key], value)) return false;
+	}
+	if (options.attributeExists !== void 0) {
+		if (!(Array.isArray(options.attributeExists) ? options.attributeExists : [options.attributeExists]).every((key) => run.attributes?.[key] !== void 0)) return false;
+	}
+	if (options.attributeMissing !== void 0) {
+		if (!(Array.isArray(options.attributeMissing) ? options.attributeMissing : [options.attributeMissing]).every((key) => run.attributes?.[key] === void 0)) return false;
+	}
+	return true;
+}
+//#endregion
+export { getRequiredStoreRun, matchesScheduleListOptions, matchesWorkflowRunListOptions, matchesWorkflowStepAttemptListOptions, querySchedules, queryWorkflowRuns, queryWorkflowStepAttempts };

package/dist/store/revision.d.mts

@@ -0,0 +1,4 @@
+//#region src/store/revision.d.ts
+declare function isSameWorkflowStorageValue(left: unknown, right: unknown): boolean;
+//#endregion
+export { isSameWorkflowStorageValue };

package/dist/store/revision.mjs

@@ -0,0 +1,7 @@
+import { deepEquals } from "@temelj/value";
+//#region src/store/revision.ts
+function isSameWorkflowStorageValue(left, right) {
+	return deepEquals(left, right);
+}
+//#endregion
+export { isSameWorkflowStorageValue };

package/dist/store/run.d.mts

@@ -0,0 +1,49 @@
+import { RunId } from "../types/run-id.mjs";
+import { WorkflowPage } from "../types/pagination.mjs";
+import { WorkflowListRunsOptions, WorkflowListRunsPageOptions } from "../types/run-list.mjs";
+import { WorkerId } from "../types/worker-id.mjs";
+import { WorkflowRunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowClaimRunOptions, WorkflowStorage } from "../types/store.mjs";
+//#region src/store/run.d.ts
+interface WorkflowRunReader {
+  getRun(runId: RunId): Promise<WorkflowRunRecord | undefined>;
+}
+interface WorkflowRunClaimReader extends WorkflowRunReader {
+  listRuns(options?: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
+}
+declare function updateRunIfCurrent(storage: WorkflowStorage, namespace: string, store: WorkflowRunReader, current: WorkflowRunRecord, next: WorkflowRunRecord): Promise<WorkflowRunRecord | undefined>;
+declare function getWorkflowRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<WorkflowRunRecord | undefined>;
+declare function listWorkflowRuns(storage: WorkflowStorage, namespace: string, options?: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
+declare function listWorkflowRunsPage(storage: WorkflowStorage, namespace: string, options?: WorkflowListRunsPageOptions): Promise<WorkflowPage<WorkflowRunRecord>>;
+declare function countWorkflowRuns(storage: WorkflowStorage, namespace: string, options?: WorkflowListRunsOptions): Promise<number>;
+declare function updateWorkflowRun(storage: WorkflowStorage, namespace: string, store: WorkflowRunReader, run: WorkflowRunRecord): Promise<WorkflowRunRecord>;
+declare function claimWorkflowRun(storage: WorkflowStorage, namespace: string, store: WorkflowRunClaimReader, options: WorkflowClaimRunOptions): Promise<WorkflowRunRecord | undefined>;
+declare function extendWorkflowRunLease(storage: WorkflowStorage, namespace: string, store: WorkflowRunReader, options: {
+  readonly runId: RunId;
+  readonly workerId: string;
+  readonly attempts?: number;
+  readonly now: Temporal.Instant;
+  readonly leaseDuration: Temporal.Duration;
+}): Promise<WorkflowRunRecord | undefined>;
+declare function releaseWorkflowRunLease(storage: WorkflowStorage, namespace: string, store: WorkflowRunReader, options: {
+  readonly runId: RunId;
+  readonly workerId: string;
+  readonly attempts?: number;
+  readonly now: Temporal.Instant;
+}): Promise<WorkflowRunRecord | undefined>;
+declare function isSameReadableWorkflowRunRevision(latest: WorkflowRunRecord | undefined, current: WorkflowRunRecord, namespace: string): boolean;
+declare function isStoredWorkflowRunRevisionCurrent(storage: WorkflowStorage, namespace: string, currentRun: WorkflowRunRecord): Promise<boolean>;
+declare function getReadableStoredWorkflowRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<WorkflowRunRecord | undefined>;
+declare function requireReadableStoredWorkflowRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<WorkflowRunRecord>;
+declare function shouldRollbackAppendedEventForRun(namespace: string, run: WorkflowRunRecord | undefined, event: EventRecord): boolean;
+declare function isWorkflowRunStaleForAppend(currentRun: WorkflowRunRecord, event: EventRecord): boolean;
+declare function rollbackAppendedEventIfRunStale(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, events: readonly EventRecord[]): Promise<boolean>;
+declare function claimedRunPatch(run: WorkflowRunRecord, workerId: WorkerId, now: Temporal.Instant, leaseDuration: Temporal.Duration): WorkflowRunRecord;
+declare function extendedRunLeasePatch(run: WorkflowRunRecord, now: Temporal.Instant, leaseDuration: Temporal.Duration): WorkflowRunRecord;
+declare function releaseRunLeasePatch(run: WorkflowRunRecord, now: Temporal.Instant): WorkflowRunRecord;
+declare function firstClaimableRun(store: WorkflowRunClaimReader, options: WorkflowClaimRunOptions, listOptions: WorkflowListRunsOptions): Promise<WorkflowRunRecord | undefined>;
+declare function canClaimRun(run: WorkflowRunRecord, options: WorkflowClaimRunOptions, listOptions: WorkflowListRunsOptions): boolean;
+declare function isStaleLeaseClaim(run: WorkflowRunRecord, now: Temporal.Instant): boolean;
+//#endregion
+export { canClaimRun, claimWorkflowRun, claimedRunPatch, countWorkflowRuns, extendWorkflowRunLease, extendedRunLeasePatch, firstClaimableRun, getReadableStoredWorkflowRun, getWorkflowRun, isSameReadableWorkflowRunRevision, isStaleLeaseClaim, isStoredWorkflowRunRevisionCurrent, isWorkflowRunStaleForAppend, listWorkflowRuns, listWorkflowRunsPage, releaseRunLeasePatch, releaseWorkflowRunLease, requireReadableStoredWorkflowRun, rollbackAppendedEventIfRunStale, shouldRollbackAppendedEventForRun, updateRunIfCurrent, updateWorkflowRun };