@temelj/workflow 0.0.0-alpha.2 → 0.0.0-alpha.4

package/dist/store/create.mjs

@@ -1,10 +1,9 @@
-import { getWorkflowStoreCapabilities } from "./capabilities.mjs";
 import { makeEventsKey } from "../store-keys.mjs";
+import { getWorkflowStoreCapabilities } from "./capabilities.mjs";
 import { claimWorkflowRun, countWorkflowRuns, extendWorkflowRunLease, getWorkflowRun, listWorkflowRuns, listWorkflowRunsPage, releaseWorkflowRunLease, updateRunIfCurrent, updateWorkflowRun } from "./run.mjs";
-import { hasMessageIdempotencyKey, repairMessageIdempotencyIndexes } from "./message-index.mjs";
+import { createRunWithIdempotency, getRunByIdempotencyKey, hasMessageIdempotencyKey, repairMessageIdempotencyIndexes } from "./indexes.mjs";
+import { appendWorkflowEvent, appendWorkflowEventIfRunCurrent, getWorkflowEvents } from "./events.mjs";
 import { cleanupRuns, listCleanupMarkers } from "./cleanup.mjs";
-import { appendWorkflowEvent, appendWorkflowEventIfRunCurrent, getWorkflowEvents } from "./event.mjs";
-import { createRunWithIdempotency, getRunByIdempotencyKey } from "./idempotency.mjs";
 import { getReadableLock, listReadableLocks, updateLockIfCurrent } from "./lock.mjs";
 import { createSchedule, getReadableSchedule, listSchedules, listSchedulesPage, updateScheduleIfCurrent } from "./schedule.mjs";
 import { countWorkflowStepAttempts, listWorkflowStepAttempts, listWorkflowStepAttemptsPage, repairWorkflowStepAttempts } from "./step-attempt.mjs";
@@ -75,15 +74,15 @@ var WorkflowStore = class {
 				if (settled) return;
 				settled = true;
 				options.signal?.removeEventListener("abort", finish);
-				disposeWorkflowStoreWatcher(unwatch);
+				disposeStoreWatcher(unwatch);
 				resolve();
 			};
 			options.signal?.addEventListener("abort", finish, { once: true });
 			this.storage.watch((event) => {
-				if (isWorkflowStorageChangeForKey(event, key)) finish();
+				if (isStorageChangeForKey(event, key)) finish();
 			}).then((unsubscribe) => {
 				unwatch = unsubscribe;
-				if (settled) disposeWorkflowStoreWatcher(unwatch);
+				if (settled) disposeStoreWatcher(unwatch);
 			}).catch(() => {
 				finish();
 			});
@@ -138,15 +137,15 @@ var WorkflowStore = class {
 		return updateLockIfCurrent(this.storage, this.namespace, current, next);
 	}
 };
-function disposeWorkflowStoreWatcher(unwatch) {
+function disposeStoreWatcher(unwatch) {
 	if (unwatch === void 0) return;
-	ignoreWorkflowStoreWatcherDisposal(unwatch());
+	ignoreStoreWatcherDisposal(unwatch());
 }
-function ignoreWorkflowStoreWatcherDisposal(result) {
+function ignoreStoreWatcherDisposal(result) {
 	if (result === void 0) return;
 	result.catch(() => {});
 }
-function isWorkflowStorageChangeForKey(event, key) {
+function isStorageChangeForKey(event, key) {
 	switch (event.type) {
 		case "set":
 		case "delete": return event.key === key;

package/dist/store/events.d.mts

@@ -0,0 +1,48 @@
+import { RunId } from "../types/ids.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { WorkflowStorage } from "../types/store.mjs";
+import { StorageCompareAndSetManyItem, StorageValue } from "@temelj/storage";
+//#region src/store/events.d.ts
+export declare function appendWorkflowEvent(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord): Promise<readonly EventRecord[]>;
+export declare function appendWorkflowEventIfRunCurrent(storage: WorkflowStorage, namespace: string, current: RunRecord, event: EventRecord): Promise<readonly EventRecord[] | undefined>;
+export declare function getWorkflowEvents(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly EventRecord[]>;
+export type EventAppendSuccessOutcome = {
+  readonly status: "appended";
+  readonly events: readonly EventRecord[];
+  readonly previousEventHistory?: StorageValue;
+} | {
+  readonly status: "duplicate";
+  readonly events: readonly EventRecord[];
+};
+type EventAppendOutcome = EventAppendSuccessOutcome | {
+  readonly status: "staleRun";
+};
+interface EventAppendAtomicProjectionPlan {
+  readonly item?: StorageCompareAndSetManyItem<StorageValue>;
+}
+type EventAppendAtomicProjectionPlanner = (attempt: number) => Promise<EventAppendAtomicProjectionPlan | undefined>;
+interface EventAppendProjectionOutcome {
+  readonly outcome: EventAppendOutcome;
+  readonly projectionPipeline?: AppendProjectionPipeline;
+}
+export declare function appendEventWithProjections(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, projectionPipeline?: AppendProjectionPipeline): Promise<EventAppendSuccessOutcome>;
+export declare function appendEventWithProjectionPipelineIfRunCurrent(storage: WorkflowStorage, namespace: string, currentRun: RunRecord, event: EventRecord): Promise<EventAppendProjectionOutcome>;
+interface AppendProjectionPipeline {
+  readonly materializesAtomically: boolean;
+  readonly planAtomicProjections?: EventAppendAtomicProjectionPlanner;
+  finalize(outcome: EventAppendSuccessOutcome): Promise<readonly EventRecord[]>;
+  finalizePostCommit(outcome: EventAppendSuccessOutcome): Promise<void>;
+}
+export declare function getStoredEventHistory(storage: WorkflowStorage, key: string): Promise<{
+  readonly raw: StorageValue | undefined;
+  readonly events: readonly EventRecord[];
+}>;
+export declare function getStoredCleanupEventHistory(storage: WorkflowStorage, key: string): Promise<{
+  readonly raw: StorageValue | undefined;
+  readonly events: readonly EventRecord[];
+}>;
+export declare function isSameEventIdentity(left: EventRecord, right: EventRecord): boolean;
+export declare function rollbackAppendedEventIfCurrent(storage: WorkflowStorage, namespace: string, runId: RunId, expectedEvents: readonly EventRecord[], previousEventHistory?: StorageValue): Promise<boolean>;
+//#endregion
+export {};

package/dist/store/events.mjs

@@ -0,0 +1,263 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { WorkflowStateError } from "../errors/base.mjs";
+import "../errors/mod.mjs";
+import { makeEventsKey, makeRunKey } from "../store-keys.mjs";
+import { eventFieldsMatch, getEventDescriptor, getEventField, isCleanupEventRecord } from "../events/descriptors.mjs";
+import { supportsAtomicBatchWrite, supportsConditionalWrite } from "./capabilities.mjs";
+import { toStorageValue } from "./storage-value.mjs";
+import { isReadableEventRecord, requireReadableStoreRun } from "./validation.mjs";
+import { isRunStaleForAppend, isStoredRunRevisionCurrent, requireReadableStoredRun, rollbackAppendedEventIfRunStale } from "./run.mjs";
+import { duplicateMessageAppendOutcome, projectMessageIdempotencyIndexForAppendOutcome } from "./indexes.mjs";
+import { createStepAttemptMaterializationStoragePlan, materializeStepAttemptForAppendOutcome } from "./materialization.mjs";
+import { deepEquals, isString } from "@temelj/value";
+//#region src/store/events.ts
+async function finalizeAppendOutcome(outcome, projectionPipeline) {
+	if (outcome.status === "staleRun") return;
+	if (projectionPipeline === void 0) throw new WorkflowStateError("Cannot finalize workflow event append without an append projection pipeline.", { code: WorkflowErrorCode.STATE_APPEND_PROJECTION_PIPELINE_MISSING });
+	return await projectionPipeline.finalize(outcome);
+}
+async function appendWorkflowEvent(storage, namespace, runId, event) {
+	await requireReadableStoredRun(storage, namespace, runId);
+	const projectionPipeline = await createAppendProjectionPipeline(storage, namespace, runId, event);
+	return await finalizeAppendOutcome(await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline), projectionPipeline);
+}
+async function appendWorkflowEventIfRunCurrent(storage, namespace, current, event) {
+	requireReadableStoreRun(current, namespace);
+	const appendOutcome = await appendEventWithProjectionPipelineIfRunCurrent(storage, namespace, current, event);
+	return await finalizeAppendOutcome(appendOutcome.outcome, appendOutcome.projectionPipeline);
+}
+async function getWorkflowEvents(storage, namespace, runId) {
+	return (await getStoredEventHistory(storage, makeEventsKey(namespace, runId))).events;
+}
+const MAX_APPEND_EVENT_ATTEMPTS = 16;
+function makeAppendedEventOutcome(events, previousEventHistory) {
+	return {
+		status: "appended",
+		events,
+		previousEventHistory
+	};
+}
+function makeStaleRunAppendOutcome() {
+	return { status: "staleRun" };
+}
+async function appendEventWithAtomicProjectionPlan(storage, namespace, runId, event, planProjection, detectDuplicate) {
+	if (!supportsAtomicBatchWrite(storage)) return await appendEventIfCurrent(storage, namespace, runId, event, {
+		detectDuplicate,
+		previousEventHistory: await storage.get(makeEventsKey(namespace, runId))
+	});
+	const eventsStorageKey = makeEventsKey(namespace, runId);
+	return await retryEventAppend(storage, eventsStorageKey, runId, event, detectDuplicate, async (appendState, attempt) => {
+		const projectionPlan = await planProjection?.(attempt);
+		return await storage.compareAndSetMany([createEventHistoryCompareAndSetItem(eventsStorageKey, appendState.raw, appendState.nextEvents), ...projectionPlan?.item === void 0 ? [] : [projectionPlan.item]]);
+	});
+}
+async function appendEventIfRunRevisionCurrentAtomically(storage, namespace, currentRun, event, detectDuplicate) {
+	const runId = currentRun.id;
+	const runStorageKey = makeRunKey(namespace, runId);
+	const eventsStorageKey = makeEventsKey(namespace, runId);
+	for (let attempt = 0; attempt < MAX_APPEND_EVENT_ATTEMPTS; attempt++) {
+		const appendState = await readEventAppendState(storage, eventsStorageKey, runId, event, detectDuplicate);
+		const duplicate = appendState.duplicate;
+		if (duplicate !== void 0) {
+			if (await storage.compareAndSetMany(createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, appendState.raw, appendState.currentEvents))) return duplicate;
+			continue;
+		}
+		if (await storage.compareAndSetMany(createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, appendState.raw, appendState.nextEvents))) return makeAppendedEventOutcome(appendState.nextEvents, appendState.raw);
+		if (event.kind === "message_sent") return makeStaleRunAppendOutcome();
+	}
+	return makeStaleRunAppendOutcome();
+}
+async function appendEventIfCurrent(storage, namespace, runId, event, options = {}) {
+	const key = makeEventsKey(namespace, runId);
+	if (!supportsConditionalWrite(storage)) {
+		const current = (await getStoredEventHistory(storage, key)).events;
+		const duplicate = options.detectDuplicate?.(runId, current, event);
+		if (duplicate !== void 0) return duplicate;
+		const events = [...current, event];
+		await storage.set(key, toStorageValue(events));
+		return makeAppendedEventOutcome(events, options.previousEventHistory);
+	}
+	return await retryEventAppend(storage, key, runId, event, options.detectDuplicate, async (appendState) => await storage.compareAndSet(key, appendState.raw, toStorageValue(appendState.nextEvents)));
+}
+/**
+* Reads the event history, returns a detected duplicate, and otherwise retries `write` until it
+* lands or the attempts run out.
+*/
+async function retryEventAppend(storage, key, runId, event, detectDuplicate, write) {
+	for (let attempt = 0; attempt < MAX_APPEND_EVENT_ATTEMPTS; attempt++) {
+		const appendState = await readEventAppendState(storage, key, runId, event, detectDuplicate);
+		if (appendState.duplicate !== void 0) return appendState.duplicate;
+		if (await write(appendState, attempt)) return makeAppendedEventOutcome(appendState.nextEvents, appendState.raw);
+	}
+	throw new WorkflowStateError(`Failed to append workflow event for run ${runId} after ${MAX_APPEND_EVENT_ATTEMPTS} attempts`, {
+		code: WorkflowErrorCode.STATE_WORKFLOW_EVENT_APPEND_FAILED,
+		details: {
+			runId,
+			attempts: MAX_APPEND_EVENT_ATTEMPTS
+		}
+	});
+}
+async function readEventAppendState(storage, eventsStorageKey, runId, event, detectDuplicate) {
+	const { raw, events: currentEvents } = await getStoredEventHistory(storage, eventsStorageKey);
+	const duplicate = detectDuplicate?.(runId, currentEvents, event);
+	return {
+		raw,
+		currentEvents,
+		duplicate,
+		nextEvents: duplicate === void 0 ? [...currentEvents, event] : currentEvents
+	};
+}
+async function appendEventWithProjections(storage, namespace, runId, event, projectionPipeline) {
+	const appendProjectionPipeline = projectionPipeline ?? await createAppendProjectionPipeline(storage, namespace, runId, event);
+	const outcome = await appendEventWithAtomicProjectionPlan(storage, namespace, runId, event, appendProjectionPipeline.planAtomicProjections, duplicateMessageAppendOutcome);
+	await appendProjectionPipeline.finalizePostCommit(outcome);
+	return outcome;
+}
+async function appendEventWithProjectionPipelineIfRunCurrent(storage, namespace, currentRun, event) {
+	const runId = currentRun.id;
+	if (isRunStaleForAppend(currentRun, event)) return { outcome: makeStaleRunAppendOutcome() };
+	const projectionPipeline = await createAppendProjectionPipeline(storage, namespace, runId, event);
+	if (event.kind === "message_sent" && !supportsAtomicBatchWrite(storage)) return await appendMessageEventIfRunCurrent(storage, namespace, currentRun, event, projectionPipeline);
+	if (!supportsAtomicBatchWrite(storage) || projectionPipeline.materializesAtomically) return workflowEventAppendProjectionOutcome(await appendEventIfRunRevisionCurrentWithPostAppendGuard(storage, namespace, currentRun, event, projectionPipeline), projectionPipeline);
+	return workflowEventAppendProjectionOutcome(await appendEventIfRunRevisionCurrentAtomically(storage, namespace, currentRun, event, duplicateMessageAppendOutcome), projectionPipeline);
+}
+function workflowEventAppendProjectionOutcome(outcome, projectionPipeline) {
+	if (projectionPipeline === void 0) return { outcome };
+	return {
+		outcome,
+		projectionPipeline
+	};
+}
+async function appendEventIfRunRevisionCurrentWithPostAppendGuard(storage, namespace, currentRun, event, projectionPipeline) {
+	const runId = currentRun.id;
+	if (!await isStoredRunRevisionCurrent(storage, namespace, currentRun)) return makeStaleRunAppendOutcome();
+	const outcome = await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline);
+	if (outcome.status !== "appended") return outcome;
+	return await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome);
+}
+async function appendMessageEventIfRunCurrent(storage, namespace, currentRun, event, projectionPipeline) {
+	const runId = currentRun.id;
+	if (!await isStoredRunRevisionCurrent(storage, namespace, currentRun)) return { outcome: makeStaleRunAppendOutcome() };
+	if (!supportsConditionalWrite(storage)) {
+		const outcome = await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline);
+		if (outcome.status !== "appended") return {
+			outcome,
+			projectionPipeline
+		};
+		return {
+			outcome: await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome),
+			projectionPipeline
+		};
+	}
+	const outcome = await appendEventIfCurrent(storage, namespace, runId, event, { detectDuplicate: duplicateMessageAppendOutcome });
+	if (outcome.status !== "appended") {
+		if (!await isStoredRunRevisionCurrent(storage, namespace, currentRun)) return {
+			outcome: makeStaleRunAppendOutcome(),
+			projectionPipeline
+		};
+		return {
+			outcome,
+			projectionPipeline
+		};
+	}
+	if (!await isStoredRunRevisionCurrent(storage, namespace, currentRun)) {
+		await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome);
+		return {
+			outcome: makeStaleRunAppendOutcome(),
+			projectionPipeline
+		};
+	}
+	return {
+		outcome: await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome),
+		projectionPipeline
+	};
+}
+async function guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome) {
+	if (await rollbackAppendedEventIfRunStale(storage, namespace, runId, event, outcome.events)) return makeStaleRunAppendOutcome();
+	return outcome;
+}
+async function createAppendProjectionPipeline(storage, namespace, runId, event) {
+	if (!supportsAtomicBatchWrite(storage)) return createAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, void 0);
+	return createAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, await createStepAttemptMaterializationStoragePlan(storage, namespace, runId, event));
+}
+function createAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, initialStepAttemptPlan) {
+	return {
+		materializesAtomically: initialStepAttemptPlan?.materializes === true,
+		planAtomicProjections: createAppendAtomicProjectionPlanner(storage, namespace, runId, event, initialStepAttemptPlan),
+		async finalize(outcome) {
+			return await projectMessageIdempotencyIndexForAppendOutcome(storage, namespace, runId, event, outcome);
+		},
+		async finalizePostCommit(outcome) {
+			if (!supportsAtomicBatchWrite(storage)) await materializeStepAttemptForAppendOutcome(storage, namespace, runId, event, outcome);
+		}
+	};
+}
+function createAppendAtomicProjectionPlanner(storage, namespace, runId, event, initialStepAttemptPlan) {
+	if (!supportsAtomicBatchWrite(storage)) return;
+	return async (attempt) => attempt === 0 && initialStepAttemptPlan !== void 0 ? initialStepAttemptPlan : await createStepAttemptMaterializationStoragePlan(storage, namespace, runId, event);
+}
+async function getStoredEventHistory(storage, key) {
+	const raw = await storage.get(key);
+	return {
+		raw,
+		events: Array.isArray(raw) ? raw.filter(isReadableEventRecord) : []
+	};
+}
+async function getStoredCleanupEventHistory(storage, key) {
+	const history = await getStoredEventHistory(storage, key);
+	return {
+		raw: history.raw,
+		events: history.events.filter(isCleanupEventRecord)
+	};
+}
+function isSameEventIdentity(left, right) {
+	if (left.kind !== right.kind || Temporal.Instant.compare(left.timestamp, right.timestamp) !== 0) return false;
+	const descriptor = getEventDescriptor(left.kind);
+	return eventFieldsMatch(left, right, descriptor.identityFields) && isSameEventValueFields(left, right, descriptor.valueIdentityFields) && isSameEventStringListFields(left, right, descriptor.stringListIdentityFields);
+}
+function isSameEventValueFields(left, right, fields = []) {
+	return fields.every((field) => deepEquals(getEventField(left, field), getEventField(right, field)));
+}
+function isSameEventStringListFields(left, right, fields = []) {
+	return fields.every((field) => {
+		const leftValue = getEventField(left, field);
+		const rightValue = getEventField(right, field);
+		const leftValues = Array.isArray(leftValue) && leftValue.every((item) => isString(item) && item.trim() !== "") ? leftValue : void 0;
+		const rightValues = Array.isArray(rightValue) && rightValue.every((item) => isString(item) && item.trim() !== "") ? rightValue : void 0;
+		if (leftValues === void 0 || rightValues === void 0) return leftValues === rightValues;
+		if (leftValues.length !== rightValues.length) return false;
+		return leftValues.every((value, index) => value === rightValues[index]);
+	});
+}
+async function rollbackAppendedEventIfCurrent(storage, namespace, runId, expectedEvents, previousEventHistory) {
+	if (expectedEvents.length === 0) return false;
+	const key = makeEventsKey(namespace, runId);
+	const rolledBackEvents = expectedEvents.slice(0, -1);
+	if (supportsConditionalWrite(storage)) return await storage.compareAndSet(key, toStorageValue(expectedEvents), previousEventHistory ?? toStorageValue(rolledBackEvents));
+	const current = (await getStoredEventHistory(storage, key)).events;
+	const expectedLast = expectedEvents.at(-1);
+	const currentLast = current.at(-1);
+	if (current.length !== expectedEvents.length || expectedLast === void 0 || currentLast === void 0 || !isSameEventIdentity(currentLast, expectedLast)) return false;
+	await storage.set(key, previousEventHistory ?? toStorageValue(rolledBackEvents));
+	return true;
+}
+function createEventHistoryCompareAndSetItem(eventsStorageKey, expected, events) {
+	return {
+		key: eventsStorageKey,
+		expected,
+		value: toStorageValue(events)
+	};
+}
+function createRunRevisionCompareAndSetItem(runStorageKey, currentRun) {
+	const value = toStorageValue(currentRun);
+	return {
+		key: runStorageKey,
+		expected: value,
+		value
+	};
+}
+function createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, expectedEvents, events) {
+	return [createRunRevisionCompareAndSetItem(runStorageKey, currentRun), createEventHistoryCompareAndSetItem(eventsStorageKey, expectedEvents, events)];
+}
+//#endregion
+export { appendEventWithProjectionPipelineIfRunCurrent, appendEventWithProjections, appendWorkflowEvent, appendWorkflowEventIfRunCurrent, getStoredCleanupEventHistory, getStoredEventHistory, getWorkflowEvents, isSameEventIdentity, rollbackAppendedEventIfCurrent };

package/dist/store/indexes.d.mts

@@ -0,0 +1,25 @@
+import { RunId } from "../types/ids.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { EventRecord } from "../types/events.mjs";
+import { IdempotencyKeyOptions, MessageIdempotencyIndex, WorkflowStorage } from "../types/store.mjs";
+import { EventAppendSuccessOutcome } from "./events.mjs";
+//#region src/store/indexes.d.ts
+interface DuplicateMessageAppendOutcome {
+  readonly status: "duplicate";
+  readonly events: readonly EventRecord[];
+}
+export declare function duplicateMessageAppendOutcome(runId: RunId, events: readonly EventRecord[], event: EventRecord): DuplicateMessageAppendOutcome | undefined;
+export declare function projectMessageIdempotencyIndexForAppendOutcome(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, outcome: EventAppendSuccessOutcome): Promise<readonly EventRecord[]>;
+export declare function repairMessageIdempotencyIndexes(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly MessageIdempotencyIndex[]>;
+export declare function hasMessageIdempotencyKey(storage: WorkflowStorage, namespace: string, runId: RunId, idempotencyKey: string): Promise<boolean>;
+export declare function messageIdempotencyIndexValuesFromEvents(events: readonly EventRecord[], runId: RunId): readonly {
+  readonly idempotencyKey: string;
+  readonly value: MessageIdempotencyIndex;
+}[];
+interface IdempotencyRunReader {
+  getRun(runId: string): Promise<RunRecord | undefined>;
+}
+export declare function createRunWithIdempotency(storage: WorkflowStorage, namespace: string, store: IdempotencyRunReader, run: RunRecord): Promise<RunRecord>;
+export declare function getRunByIdempotencyKey(storage: WorkflowStorage, namespace: string, store: IdempotencyRunReader, options: IdempotencyKeyOptions): Promise<RunRecord | undefined>;
+//#endregion
+export {};

package/dist/store/indexes.mjs

@@ -0,0 +1,282 @@
+import { WorkflowStateError } from "../errors/base.mjs";
+import { WorkflowMessageIdempotencyConflictError } from "../errors/message.mjs";
+import "../errors/mod.mjs";
+import { makeEventsKey, makeIdempotencyKey, makeMessageIdempotencyKey, makeRunKey } from "../store-keys.mjs";
+import { History } from "../history/replay.mjs";
+import { supportsAtomicBatchWrite, supportsConditionalWrite } from "./capabilities.mjs";
+import { toStorageValue } from "./storage-value.mjs";
+import { isReadableRunRecord, isSameMessageIdempotencyIndex } from "./validation.mjs";
+import { requireReadableStoredRun } from "./run.mjs";
+import { getStoredEventHistory, rollbackAppendedEventIfCurrent } from "./events.mjs";
+import { deepEquals, isString } from "@temelj/value";
+//#region src/store/indexes.ts
+function duplicateMessageAppendOutcome(runId, events, event) {
+	if (!isMessageIdempotencyEvent(event)) return;
+	const existing = new History(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 && deepEquals(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 requireReadableStoredRun(storage, namespace, runId);
+	const indexedEvent = indexableMessageEventByIdempotencyKey(new History(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 (!supportsConditionalWrite(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;
+	const current = await storage.get(key);
+	if (isSameMessageIdempotencyIndex(current, 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 requireReadableStoredRun(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 requireReadableStoredRun(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 History(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 && 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 (!supportsConditionalWrite(storage)) {
+		await storage.set(key, toStorageValue(value));
+		return;
+	}
+	if (!await storage.compareAndSet(key, current, toStorageValue(value))) WorkflowMessageIdempotencyConflictError.conflict({
+		runId,
+		messageId: value.messageId,
+		idempotencyKey
+	});
+}
+const MAX_IDEMPOTENT_CREATE_WAIT_ATTEMPTS = 16;
+async function createRunWithIdempotency(storage, namespace, store, run) {
+	if (run.namespace !== namespace) throw WorkflowStateError.runNamespaceMismatch(String(run.namespace), namespace);
+	const keyOptions = idempotencyKeyOptionsForRun(run);
+	if (supportsAtomicBatchWrite(storage)) return await createRunAtomicallyWithIdempotency(storage, namespace, store, run, keyOptions);
+	const idempotencyClaim = keyOptions === void 0 ? void 0 : await claimIdempotencyIndex(storage, namespace, store, run, keyOptions);
+	if (idempotencyClaim?.status === "existing") return idempotencyClaim.run;
+	if (keyOptions !== void 0) assertIdempotencyClaimed(run.id, idempotencyClaim);
+	try {
+		await createRunRecordAndEventHistory(storage, namespace, run);
+		return run;
+	} catch (error) {
+		await rollbackIdempotencyClaim(storage, idempotencyClaim);
+		throw error;
+	}
+}
+async function createRunRecordAndEventHistory(storage, namespace, run) {
+	const runKey = makeRunKey(namespace, run.id);
+	const eventsKey = makeEventsKey(namespace, run.id);
+	let claim = {};
+	try {
+		if (!supportsConditionalWrite(storage)) {
+			if (await storage.get(runKey) !== void 0) WorkflowStateError.runIdAlreadyExists(run.id);
+			if (await storage.get(eventsKey) !== void 0) WorkflowStateError.eventHistoryAlreadyExists(run.id);
+			await storage.set(runKey, toStorageValue(run));
+			claim = { runKey };
+			await storage.set(eventsKey, toStorageValue([]));
+			return {
+				...claim,
+				eventsKey
+			};
+		}
+		if (!await storage.compareAndSet(runKey, void 0, toStorageValue(run))) WorkflowStateError.runIdAlreadyExists(run.id);
+		claim = { runKey };
+		if (!await storage.compareAndSet(eventsKey, void 0, toStorageValue([]))) WorkflowStateError.eventHistoryAlreadyExists(run.id);
+		return {
+			...claim,
+			eventsKey
+		};
+	} catch (error) {
+		await rollbackRunCreationClaim(storage, claim);
+		throw error;
+	}
+}
+async function rollbackRunCreationClaim(storage, claim) {
+	await storage.deleteMany([...claim.runKey === void 0 ? [] : [claim.runKey], ...claim.eventsKey === void 0 ? [] : [claim.eventsKey]]);
+}
+async function rollbackIdempotencyClaim(storage, claim) {
+	if (claim?.status !== "claimed") return;
+	if (!supportsConditionalWrite(storage)) {
+		await storage.delete(claim.key);
+		return;
+	}
+	await storage.compareAndSet(claim.key, claim.value, void 0);
+}
+async function claimIdempotencyIndex(storage, namespace, store, run, keyOptions) {
+	const key = makeIdempotencyKey(namespace, keyOptions);
+	const value = toStorageValue(run.id);
+	if (!supportsConditionalWrite(storage)) {
+		const existingRun = await getRunByIdempotencyKey(storage, namespace, store, keyOptions);
+		if (existingRun !== void 0) return {
+			status: "existing",
+			run: existingRun
+		};
+		await storage.set(key, value);
+		return {
+			status: "claimed",
+			key,
+			value
+		};
+	}
+	if (await storage.compareAndSet(key, void 0, value)) return {
+		status: "claimed",
+		key,
+		value
+	};
+	const existingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
+	if (existingRun !== void 0) return {
+		status: "existing",
+		run: existingRun
+	};
+	if (!await releaseStaleIdempotencyIndex(storage, namespace, store, keyOptions)) WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
+	if (await storage.compareAndSet(key, void 0, value)) return {
+		status: "claimed",
+		key,
+		value
+	};
+	const reclaimedExistingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
+	if (reclaimedExistingRun !== void 0) return {
+		status: "existing",
+		run: reclaimedExistingRun
+	};
+	WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
+}
+function assertIdempotencyClaimed(runId, claim) {
+	if (claim?.status !== "claimed") WorkflowStateError.idempotencyKeyClaimedWithoutRun(runId);
+}
+async function createRunAtomicallyWithIdempotency(storage, namespace, store, run, keyOptions) {
+	for (let attempt = 0; attempt < 2; attempt++) {
+		if (await storage.compareAndSetMany([
+			...atomicIdempotencyClaimItems(namespace, run, keyOptions),
+			{
+				key: makeRunKey(namespace, run.id),
+				expected: void 0,
+				value: toStorageValue(run)
+			},
+			{
+				key: makeEventsKey(namespace, run.id),
+				expected: void 0,
+				value: toStorageValue([])
+			}
+		])) return run;
+		if (keyOptions === void 0) WorkflowStateError.runIdAlreadyExists(run.id);
+		const existingRun = await waitForRunByIdempotencyKey(storage, namespace, store, keyOptions);
+		if (existingRun !== void 0) return existingRun;
+		if (attempt === 0 && await releaseStaleIdempotencyIndex(storage, namespace, store, keyOptions)) continue;
+		WorkflowStateError.idempotencyKeyClaimedWithoutRun(run.id);
+	}
+	throw WorkflowStateError.runIdAlreadyExists(run.id);
+}
+function atomicIdempotencyClaimItems(namespace, run, keyOptions) {
+	return keyOptions === void 0 ? [] : [{
+		key: makeIdempotencyKey(namespace, keyOptions),
+		expected: void 0,
+		value: toStorageValue(run.id)
+	}];
+}
+async function getRunByIdempotencyKey(storage, namespace, store, options) {
+	const runId = await storage.get(makeIdempotencyKey(namespace, options));
+	if (!(isString(runId) && runId.trim() !== "")) return;
+	const run = await store.getRun(runId);
+	return run !== void 0 && isReadableRunRecord(run, run.namespace) && run.workflowName === options.workflowName && run.workflowVersion === options.workflowVersion && run.idempotencyKey === options.idempotencyKey ? run : void 0;
+}
+function idempotencyKeyOptionsForRun(run) {
+	if (run.idempotencyKey === void 0) return void 0;
+	return {
+		workflowName: run.workflowName,
+		workflowVersion: run.workflowVersion,
+		idempotencyKey: run.idempotencyKey
+	};
+}
+async function waitForRunByIdempotencyKey(storage, namespace, store, options) {
+	for (let attempt = 0; attempt < MAX_IDEMPOTENT_CREATE_WAIT_ATTEMPTS; attempt++) {
+		const run = await getRunByIdempotencyKey(storage, namespace, store, options);
+		if (run !== void 0) return run;
+		await Promise.resolve();
+	}
+}
+async function releaseStaleIdempotencyIndex(storage, namespace, store, options) {
+	if (!supportsConditionalWrite(storage)) return false;
+	const key = makeIdempotencyKey(namespace, options);
+	const value = await storage.get(key);
+	if (value === void 0) return false;
+	if (isString(value) && value.trim() !== "") {
+		const run = await store.getRun(value);
+		if (run !== void 0 && isReadableRunRecord(run, run.namespace) && run.workflowName === options.workflowName && run.workflowVersion === options.workflowVersion && run.idempotencyKey === options.idempotencyKey) return false;
+	}
+	return await storage.compareAndSet(key, value, void 0);
+}
+//#endregion
+export { createRunWithIdempotency, duplicateMessageAppendOutcome, getRunByIdempotencyKey, hasMessageIdempotencyKey, messageIdempotencyIndexValuesFromEvents, projectMessageIdempotencyIndexForAppendOutcome, repairMessageIdempotencyIndexes };