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

package/dist/store/instrumentation.d.mts

@@ -2,6 +2,5 @@ import { Telemetry } from "../types/telemetry.mjs";
 import { WorkflowStorage } from "../types/store.mjs";
 //#region src/store/instrumentation.d.ts
 /** Wraps workflow storage operations with telemetry. */
-declare function instrumentWorkflowStorage(storage: WorkflowStorage, telemetry: Telemetry | undefined): WorkflowStorage;
-//#endregion
-export { instrumentWorkflowStorage };
+export declare function instrumentStorage(storage: WorkflowStorage, telemetry: Telemetry | undefined): WorkflowStorage;
+//#endregion

package/dist/store/instrumentation.mjs

@@ -1,7 +1,7 @@
 import { withStorageTelemetry } from "../telemetry.mjs";
 //#region src/store/instrumentation.ts
 /** Wraps workflow storage operations with telemetry. */
-function instrumentWorkflowStorage(storage, telemetry) {
+function instrumentStorage(storage, telemetry) {
 	if (telemetry?.withStorageOperation === void 0) return storage;
 	const backend = storage.engine.name;
 	const run = async (operation, callback) => await withStorageTelemetry(telemetry, {
@@ -30,94 +30,94 @@ function instrumentWorkflowStorage(storage, telemetry) {
 			return storage.listenerCount(pattern);
 		},
 		async watch(callback) {
-			return await run("watch", async () => await storage.watch(callback));
+			return await run("watch", () => storage.watch(callback));
 		},
 		async unwatch() {
-			await run("unwatch", async () => await storage.unwatch());
+			await run("unwatch", () => storage.unwatch());
 		},
 		async get(key) {
-			return await run("get", async () => await storage.get(key));
+			return await run("get", () => storage.get(key));
 		},
 		async tryGet(key) {
-			return await run("tryGet", async () => await storage.tryGet(key));
+			return await run("tryGet", () => storage.tryGet(key));
 		},
 		async set(key, value, options) {
-			await run("set", async () => await storage.set(key, value, options));
+			await run("set", () => storage.set(key, value, options));
 		},
 		async trySet(key, value, options) {
-			return await run("trySet", async () => await storage.trySet(key, value, options));
+			return await run("trySet", () => storage.trySet(key, value, options));
 		},
 		async compareAndSet(key, expected, value, options) {
-			return await run("compareAndSet", async () => await storage.compareAndSet(key, expected, value, options));
+			return await run("compareAndSet", () => storage.compareAndSet(key, expected, value, options));
 		},
 		async tryCompareAndSet(key, expected, value, options) {
-			return await run("tryCompareAndSet", async () => await storage.tryCompareAndSet(key, expected, value, options));
+			return await run("tryCompareAndSet", () => storage.tryCompareAndSet(key, expected, value, options));
 		},
 		async compareAndSetMany(items) {
-			return await run("compareAndSetMany", async () => await storage.compareAndSetMany(items));
+			return await run("compareAndSetMany", () => storage.compareAndSetMany(items));
 		},
 		async tryCompareAndSetMany(items) {
-			return await run("tryCompareAndSetMany", async () => await storage.tryCompareAndSetMany(items));
+			return await run("tryCompareAndSetMany", () => storage.tryCompareAndSetMany(items));
 		},
 		async has(key) {
-			return await run("has", async () => await storage.has(key));
+			return await run("has", () => storage.has(key));
 		},
 		async tryHas(key) {
-			return await run("tryHas", async () => await storage.tryHas(key));
+			return await run("tryHas", () => storage.tryHas(key));
 		},
 		async delete(key) {
-			return await run("delete", async () => await storage.delete(key));
+			return await run("delete", () => storage.delete(key));
 		},
 		async tryDelete(key) {
-			return await run("tryDelete", async () => await storage.tryDelete(key));
+			return await run("tryDelete", () => storage.tryDelete(key));
 		},
 		async getMany(keys) {
-			return await run("getMany", async () => await storage.getMany(keys));
+			return await run("getMany", () => storage.getMany(keys));
 		},
 		async tryGetMany(keys) {
-			return await run("tryGetMany", async () => await storage.tryGetMany(keys));
+			return await run("tryGetMany", () => storage.tryGetMany(keys));
 		},
 		async setMany(items) {
-			await run("setMany", async () => await storage.setMany(items));
+			await run("setMany", () => storage.setMany(items));
 		},
 		async trySetMany(items) {
-			return await run("trySetMany", async () => await storage.trySetMany(items));
+			return await run("trySetMany", () => storage.trySetMany(items));
 		},
 		async deleteMany(keys) {
-			return await run("deleteMany", async () => await storage.deleteMany(keys));
+			return await run("deleteMany", () => storage.deleteMany(keys));
 		},
 		async tryDeleteMany(keys) {
-			return await run("tryDeleteMany", async () => await storage.tryDeleteMany(keys));
+			return await run("tryDeleteMany", () => storage.tryDeleteMany(keys));
 		},
 		async keys(options) {
-			return await run("keys", async () => await storage.keys(options));
+			return await run("keys", () => storage.keys(options));
 		},
 		async tryKeys(options) {
-			return await run("tryKeys", async () => await storage.tryKeys(options));
+			return await run("tryKeys", () => storage.tryKeys(options));
 		},
 		async entries(options) {
-			return await run("entries", async () => await storage.entries(options));
+			return await run("entries", () => storage.entries(options));
 		},
 		async tryEntries(options) {
-			return await run("tryEntries", async () => await storage.tryEntries(options));
+			return await run("tryEntries", () => storage.tryEntries(options));
 		},
 		async clear(options) {
-			await run("clear", async () => await storage.clear(options));
+			await run("clear", () => storage.clear(options));
 		},
 		async tryClear(options) {
-			return await run("tryClear", async () => await storage.tryClear(options));
+			return await run("tryClear", () => storage.tryClear(options));
 		},
 		async dispose() {
-			await run("dispose", async () => await storage.dispose());
+			await run("dispose", () => storage.dispose());
 		},
 		async [Symbol.asyncDispose]() {
 			await instrumented.dispose();
 		},
 		async tryDispose() {
-			return await run("tryDispose", async () => await storage.tryDispose());
+			return await run("tryDispose", () => storage.tryDispose());
 		}
 	};
 	return instrumented;
 }
 //#endregion
-export { instrumentWorkflowStorage };
+export { instrumentStorage };

package/dist/store/lock.d.mts

@@ -1,8 +1,7 @@
 import { LockRecord } from "../types/lock.mjs";
 import { WorkflowStorage } from "../types/store.mjs";
 //#region src/store/lock.d.ts
-declare function getReadableLock(storage: WorkflowStorage, namespace: string, key: string): Promise<LockRecord | undefined>;
-declare function listReadableLocks(storage: WorkflowStorage, namespace: string): Promise<readonly LockRecord[]>;
-declare function updateLockIfCurrent(storage: WorkflowStorage, namespace: string, current: LockRecord | undefined, next: LockRecord): Promise<LockRecord | undefined>;
-//#endregion
-export { getReadableLock, listReadableLocks, updateLockIfCurrent };
+export declare function getReadableLock(storage: WorkflowStorage, namespace: string, key: string): Promise<LockRecord | undefined>;
+export declare function listReadableLocks(storage: WorkflowStorage, namespace: string): Promise<readonly LockRecord[]>;
+export declare function updateLockIfCurrent(storage: WorkflowStorage, namespace: string, current: LockRecord | undefined, next: LockRecord): Promise<LockRecord | undefined>;
+//#endregion

package/dist/store/lock.mjs

@@ -1,28 +1,26 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowLockStateError } from "../errors/lock.mjs";
 import "../errors/mod.mjs";
+import { omitUndefined, uniqueBy } from "../collection.mjs";
 import { makeLockKey, makeLockKeyPrefix } from "../store-keys.mjs";
 import { toStorageValue } from "./storage-value.mjs";
 import { isReadableLockRecord } from "./validation.mjs";
-import { compactWorkflowStoreRecord } from "./compaction.mjs";
 //#region src/store/lock.ts
 async function getReadableLock(storage, namespace, key) {
 	const lock = await storage.get(makeLockKey(namespace, key));
 	return isReadableLockRecord(lock, namespace) ? lock : void 0;
 }
 async function listReadableLocks(storage, namespace) {
-	return (await storage.entries({ prefix: makeLockKeyPrefix(namespace) })).map((entry) => entry.value).filter((lock) => isReadableLockRecord(lock, namespace)).sort((a, b) => a.key.localeCompare(b.key)).filter(isFirstLockRecordForKey);
+	return uniqueBy((await storage.entries({ prefix: makeLockKeyPrefix(namespace) })).map((entry) => entry.value).filter((lock) => isReadableLockRecord(lock, namespace)).sort((a, b) => a.key.localeCompare(b.key)), (lock) => lock.key);
 }
 async function updateLockIfCurrent(storage, namespace, current, next) {
 	if (next.namespace !== namespace) WorkflowLockStateError.namespaceMismatch(String(next.namespace), namespace);
 	if (current !== void 0) {
 		if (current.namespace !== namespace) WorkflowLockStateError.namespaceMismatch(String(current.namespace), namespace);
-		if (current.key !== next.key) WorkflowLockStateError.keyChangeRejected();
+		if (current.key !== next.key) throw new WorkflowLockStateError("Workflow lock key cannot change", WorkflowErrorCode.LOCK_KEY_CHANGE_REJECTED, void 0);
 	}
-	const compact = compactWorkflowStoreRecord(next);
+	const compact = omitUndefined(next);
 	return await storage.compareAndSet(makeLockKey(namespace, next.key), current === void 0 ? void 0 : toStorageValue(current), toStorageValue(compact)) ? compact : void 0;
 }
-function isFirstLockRecordForKey(lock, index, locks) {
-	return locks.findIndex((entry) => entry.key === lock.key) === index;
-}
 //#endregion
 export { getReadableLock, listReadableLocks, updateLockIfCurrent };

package/dist/store/materialization.d.mts

@@ -1,30 +1,23 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
-import "../types/run.mjs";
+import { RunId } from "../types/ids.mjs";
+import { StepAttemptRecord } from "../types/step-attempts.mjs";
 import { EventRecord } from "../types/events.mjs";
 import { WorkflowStorage } from "../types/store.mjs";
 import { StorageCompareAndSetManyItem, StorageValue } from "@temelj/storage";
 //#region src/store/materialization.d.ts
-interface WorkflowStepAttemptMaterializationStoragePlan {
+export interface StepAttemptMaterializationStoragePlan {
   readonly materializes: boolean;
   readonly storageKey?: string;
-  readonly current?: WorkflowStepAttemptRecord;
+  readonly current?: StepAttemptRecord;
   readonly item?: StorageCompareAndSetManyItem<StorageValue>;
 }
-interface WorkflowStepAttemptAppendMaterializationOutcome {
+interface StepAttemptAppendMaterializationOutcome {
   readonly status: "appended" | "duplicate";
   readonly events: readonly EventRecord[];
   readonly previousEventHistory?: StorageValue;
 }
-declare function materializeStepAttemptForAppendOutcome(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, outcome: WorkflowStepAttemptAppendMaterializationOutcome): Promise<void>;
-declare function createWorkflowStepAttemptMaterializationStoragePlan(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord): Promise<WorkflowStepAttemptMaterializationStoragePlan>;
-declare function reconcileStepAttempts(storage: WorkflowStorage, namespace: string, runId: RunId, events: readonly EventRecord[]): Promise<readonly WorkflowStepAttemptRecord[]>;
-declare function materializeStepAttemptIfCurrent(storage: WorkflowStorage, runId: RunId, storageKey: string, createNext: (current: WorkflowStepAttemptRecord | undefined) => WorkflowStepAttemptRecord | undefined, options?: {
-  readonly repairStatusMismatch?: boolean;
-}): Promise<void>;
-declare function shouldStoreStepAttempt(current: WorkflowStepAttemptRecord | undefined, next: WorkflowStepAttemptRecord, options?: {
-  readonly repairStatusMismatch?: boolean;
-}): boolean;
-declare function isSameStepAttemptIdentity(current: WorkflowStepAttemptRecord, next: WorkflowStepAttemptRecord): boolean;
+export declare function materializeStepAttemptForAppendOutcome(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, outcome: StepAttemptAppendMaterializationOutcome): Promise<void>;
+export declare function createStepAttemptMaterializationStoragePlan(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord): Promise<StepAttemptMaterializationStoragePlan>;
+export declare function reconcileStepAttempts(storage: WorkflowStorage, namespace: string, runId: RunId, events: readonly EventRecord[]): Promise<readonly StepAttemptRecord[]>;
+export declare function isSameStepAttemptIdentity(current: StepAttemptRecord, next: StepAttemptRecord): boolean;
 //#endregion
-export { WorkflowStepAttemptAppendMaterializationOutcome, WorkflowStepAttemptMaterializationStoragePlan, createWorkflowStepAttemptMaterializationStoragePlan, isSameStepAttemptIdentity, materializeStepAttemptForAppendOutcome, materializeStepAttemptIfCurrent, reconcileStepAttempts, shouldStoreStepAttempt };
+export {};

package/dist/store/materialization.mjs

@@ -1,16 +1,16 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
-import { makeWorkflowStepAttemptKey } from "../history/attempt-key.mjs";
 import { omitUndefined } from "../collection.mjs";
+import { makeStepAttemptKey, stepAttemptKey } from "../store-keys.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 { applyStepAttemptEvent } from "../history/projection.mjs";
+import "../history/replay.mjs";
+import { createStepAttempts } from "../history/step-attempts.mjs";
+import { supportsConditionalWrite } from "./capabilities.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";
+import { parseStoredStepAttemptRecord } from "./validation.mjs";
+import { requireReadableStoredRun } from "./run.mjs";
+import { rollbackAppendedEventIfCurrent } from "./events.mjs";
 //#region src/store/materialization.ts
 const MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS = 16;
 const WORKFLOW_MATERIALIZED_STEP_DESCRIPTORS = {
@@ -28,9 +28,9 @@ const WORKFLOW_MATERIALIZED_STEP_DESCRIPTORS = {
 	deterministic: { identityFields: [] }
 };
 async function materializeStepAttempt(storage, namespace, runId, event) {
-	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+	const storageKey = getStepAttemptMaterializationStorageKey(namespace, runId, event);
 	if (storageKey === void 0) return;
-	await materializeStepAttemptIfCurrent(storage, runId, storageKey, (current) => applyWorkflowStepAttemptEvent(runId, event, current));
+	await materializeStepAttemptIfCurrent(storage, runId, storageKey, (current) => applyStepAttemptEvent(runId, event, current));
 }
 async function materializeStepAttemptForAppendOutcome(storage, namespace, runId, event, outcome) {
 	try {
@@ -40,7 +40,7 @@ async function materializeStepAttemptForAppendOutcome(storage, namespace, runId,
 		throw error;
 	}
 }
-function getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event) {
+function getStepAttemptMaterializationStorageKey(namespace, runId, event) {
 	let attemptKey;
 	try {
 		attemptKey = getWorkflowEventStepAttemptKey(event);
@@ -49,58 +49,64 @@ function getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event
 	}
 	return attemptKey === void 0 ? void 0 : makeStepAttemptKey(namespace, runId, attemptKey);
 }
-function createWorkflowStepAttemptMaterializationUpdate(namespace, runId, event, current) {
-	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+function createStepAttemptMaterializationUpdate(namespace, runId, event, current) {
+	const storageKey = getStepAttemptMaterializationStorageKey(namespace, runId, event);
 	if (storageKey === void 0) return;
-	const next = applyWorkflowStepAttemptEvent(runId, event, current);
+	const next = applyStepAttemptEvent(runId, event, current);
 	return {
 		storageKey,
-		...next === void 0 ? {} : { next },
+		next,
 		shouldStore: next !== void 0 && shouldStoreStepAttempt(current, next)
 	};
 }
-async function createWorkflowStepAttemptMaterializationStoragePlan(storage, namespace, runId, event) {
-	const storageKey = getWorkflowStepAttemptMaterializationStorageKey(namespace, runId, event);
+async function createStepAttemptMaterializationStoragePlan(storage, namespace, runId, event) {
+	const storageKey = getStepAttemptMaterializationStorageKey(namespace, runId, event);
 	if (storageKey === void 0) return { materializes: false };
-	const { raw, current } = await readStoredWorkflowStepAttempt(storage, storageKey);
-	const materialization = createWorkflowStepAttemptMaterializationUpdate(namespace, runId, event, current);
+	const { raw, current } = await readStoredStepAttempt(storage, storageKey);
+	const materialization = createStepAttemptMaterializationUpdate(namespace, runId, event, current);
 	return {
 		materializes: true,
 		storageKey,
-		...current === void 0 ? {} : { current },
-		...materialization?.shouldStore === true && materialization.next !== void 0 ? { item: {
+		current,
+		item: materialization?.shouldStore === true && materialization.next !== void 0 ? {
 			key: materialization.storageKey,
 			expected: raw,
 			value: toStorageValue(omitUndefined(materialization.next))
-		} } : {}
+		} : void 0
 	};
 }
 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 })));
+	const attempts = createStepAttempts(runId, events);
+	await requireReadableStoredRun(storage, namespace, runId);
+	await Promise.all(attempts.map((attempt) => materializeStepAttemptIfCurrent(storage, runId, makeStepAttemptKey(namespace, runId, stepAttemptKey(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);
+	if (!supportsConditionalWrite(storage)) {
+		const { current } = await readStoredStepAttempt(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 { raw, current } = await readStoredStepAttempt(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);
+	throw new WorkflowStateError(`Failed to materialize workflow step attempt for run ${runId} after ${MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS} attempts`, {
+		code: WorkflowErrorCode.STATE_STEP_ATTEMPT_MATERIALIZATION_FAILED,
+		details: {
+			runId,
+			attempts: MAX_MATERIALIZE_STEP_ATTEMPT_ATTEMPTS
+		}
+	});
 }
-async function readStoredWorkflowStepAttempt(storage, storageKey) {
+async function readStoredStepAttempt(storage, storageKey) {
 	const raw = await storage.get(storageKey);
 	return {
 		raw,
-		current: parseStoredWorkflowStepAttemptRecord(raw)
+		current: parseStoredStepAttemptRecord(raw)
 	};
 }
 function shouldStoreStepAttempt(current, next, options = {}) {
@@ -124,4 +130,4 @@ function isSameMaterializedStepAttemptFields(current, next, fields) {
 	return fields.every((field) => current[field] === next[field]);
 }
 //#endregion
-export { createWorkflowStepAttemptMaterializationStoragePlan, isSameStepAttemptIdentity, materializeStepAttemptForAppendOutcome, materializeStepAttemptIfCurrent, reconcileStepAttempts, shouldStoreStepAttempt };
+export { createStepAttemptMaterializationStoragePlan, isSameStepAttemptIdentity, materializeStepAttemptForAppendOutcome, reconcileStepAttempts };

package/dist/store/mod.d.mts

@@ -1,5 +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 { ClaimRunOptions, CleanupIndexKey, CreateWorkflowStoreOptions, ExtendRunLeaseOptions, IdempotencyKeyOptions, MessageIdempotencyIndex, ReleaseRunLeaseOptions, StoreCapabilities, WorkflowEventHistoryChangeWaitOptions, WorkflowStorage } from "../types/store.mjs";
+import { cleanupIndexKeySchema, cleanupMarkerRecordSchema, cleanupModeSchema, messageIdempotencyIndexSchema, stepAttemptRecordSchema, stepAttemptStatusSchema } from "../schema/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 };
+export { type ClaimRunOptions, type CleanupIndexKey, type CreateWorkflowStoreOptions, type ExtendRunLeaseOptions, type IdempotencyKeyOptions, type MessageIdempotencyIndex, type ReleaseRunLeaseOptions, type StoreCapabilities, type WorkflowEventHistoryChangeWaitOptions, type WorkflowStorage, WorkflowStore, cleanupIndexKeySchema, cleanupMarkerRecordSchema, cleanupModeSchema, createWorkflowStore, getWorkflowStoreCapabilities, messageIdempotencyIndexSchema, stepAttemptRecordSchema, stepAttemptStatusSchema };

package/dist/store/mod.mjs

@@ -1,4 +1,4 @@
 import { getWorkflowStoreCapabilities } from "./capabilities.mjs";
-import { workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema } from "./schema.mjs";
+import { cleanupIndexKeySchema, cleanupMarkerRecordSchema, cleanupModeSchema, messageIdempotencyIndexSchema, stepAttemptRecordSchema, stepAttemptStatusSchema } from "../schema/store.mjs";
 import { WorkflowStore, createWorkflowStore } from "./create.mjs";
-export { WorkflowStore, createWorkflowStore, getWorkflowStoreCapabilities, workflowCleanupIndexKeySchema, workflowMessageIdempotencyIndexSchema };
+export { WorkflowStore, cleanupIndexKeySchema, cleanupMarkerRecordSchema, cleanupModeSchema, createWorkflowStore, getWorkflowStoreCapabilities, messageIdempotencyIndexSchema, stepAttemptRecordSchema, stepAttemptStatusSchema };

package/dist/store/query.d.mts

@@ -1,24 +1,20 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.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";
+import { ListRunsOptions } from "../types/run-list.mjs";
+import { ListStepAttemptsOptions, StepAttemptRecord } from "../types/step-attempts.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { WorkflowStorage, WorkflowStore } 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: {
+export declare function queryRuns(storage: WorkflowStorage, namespace: string, options: ListRunsOptions | 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: {
+}): Promise<readonly RunRecord[]>;
+export declare function queryStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStore, runId: RunId, options: ListStepAttemptsOptions | undefined, _query: {
   readonly label: string;
-}): Promise<readonly WorkflowStepAttemptRecord[]>;
-declare function querySchedules(storage: WorkflowStorage, namespace: string, options: ListSchedulesOptions | undefined, _query: {
+}): Promise<readonly StepAttemptRecord[]>;
+export 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 };
+export declare function getRequiredRun(store: WorkflowStore, runId: RunId): Promise<RunRecord>;
+export declare function matchesRunListOptions(run: RunRecord, options: ListRunsOptions | undefined): boolean;
+//#endregion

package/dist/store/query.mjs

@@ -1,26 +1,26 @@
+import { compareOptionalTimestamps, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange } from "../temporal.mjs";
 import { WorkflowRunNotFoundError } from "../errors/run.mjs";
 import "../errors/mod.mjs";
 import { matchesOptionalValue, uniqueBy } from "../collection.mjs";
-import { compareOptionalTimestamps, matchesOptionalDurationRange, matchesOptionalTimestampRange, matchesTimestampRange } from "../temporal.mjs";
 import { makeRunKeyPrefix, makeScheduleKeyPrefix } from "../store-keys.mjs";
-import { isListableWorkflowRunRecord, isReadableScheduleRecord } from "./validation.mjs";
+import { isListableRunRecord, isReadableScheduleRecord } from "./validation.mjs";
 import { reconcileStepAttempts } from "./materialization.mjs";
 //#region src/store/query.ts
-async function queryWorkflowRuns(storage, namespace, options, query) {
-	const runs = (await storage.entries({ prefix: makeRunKeyPrefix(namespace) })).map((entry) => entry.value).filter((run) => isListableWorkflowRunRecord(run, namespace)).filter((run) => matchesWorkflowRunListOptions(run, options));
+async function queryRuns(storage, namespace, options, query) {
+	const runs = (await storage.entries({ prefix: makeRunKeyPrefix(namespace) })).map((entry) => entry.value).filter((run) => isListableRunRecord(run, namespace)).filter((run) => matchesRunListOptions(run, options));
 	const uniqueRuns = uniqueBy(runs, (run) => run.id);
 	if (!query.sort) return uniqueRuns;
-	return [...uniqueRuns].sort(compareWorkflowRunsForQuery);
+	return [...uniqueRuns].sort(compareRunsForQuery);
 }
-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 queryStepAttempts(storage, namespace, store, runId, options, _query) {
+	await getRequiredRun(store, runId);
+	return (await reconcileStepAttempts(storage, namespace, runId, await store.getEvents(runId))).filter((attempt) => matchesStepAttemptListOptions(attempt, options));
 }
 async function querySchedules(storage, namespace, options, _query) {
 	const schedules = (await storage.entries({ prefix: makeScheduleKeyPrefix(namespace) })).map((entry) => entry.value).filter((schedule) => isReadableScheduleRecord(schedule, namespace)).filter((schedule) => matchesScheduleListOptions(schedule, options)).sort(compareSchedulesForQuery);
 	return uniqueBy(schedules, (schedule) => schedule.id);
 }
-function compareWorkflowRunsForQuery(left, right) {
+function compareRunsForQuery(left, right) {
 	const createdOrder = compareOptionalTimestamps(left.createdAt, right.createdAt);
 	if (createdOrder !== 0) return createdOrder;
 	return left.id.localeCompare(right.id);
@@ -28,12 +28,12 @@ function compareWorkflowRunsForQuery(left, right) {
 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) {
+async function getRequiredRun(store, runId) {
 	const run = await store.getRun(runId);
 	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
 	return run;
 }
-function matchesWorkflowRunListOptions(run, options) {
+function matchesRunListOptions(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;
@@ -48,7 +48,7 @@ function matchesWorkflowRunListOptions(run, options) {
 	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) {
+function matchesStepAttemptListOptions(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;
@@ -81,4 +81,4 @@ function matchesRunAttributeFilters(run, options) {
 	return true;
 }
 //#endregion
-export { getRequiredStoreRun, matchesScheduleListOptions, matchesWorkflowRunListOptions, matchesWorkflowStepAttemptListOptions, querySchedules, queryWorkflowRuns, queryWorkflowStepAttempts };
+export { getRequiredRun, matchesRunListOptions, queryRuns, querySchedules, queryStepAttempts };

package/dist/store/run.d.mts

@@ -1,49 +1,40 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.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 { ListRunsOptions, ListRunsPageOptions } from "../types/run-list.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowClaimRunOptions, WorkflowStorage } from "../types/store.mjs";
+import { ClaimRunOptions, WorkflowStorage } from "../types/store.mjs";
 //#region src/store/run.d.ts
-interface WorkflowRunReader {
-  getRun(runId: RunId): Promise<WorkflowRunRecord | undefined>;
+interface RunReader {
+  getRun(runId: RunId): Promise<RunRecord | undefined>;
 }
-interface WorkflowRunClaimReader extends WorkflowRunReader {
-  listRuns(options?: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
+interface RunClaimReader extends RunReader {
+  listRuns(options?: ListRunsOptions): Promise<readonly RunRecord[]>;
 }
-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: {
+export declare function updateRunIfCurrent(storage: WorkflowStorage, namespace: string, store: RunReader, current: RunRecord, next: RunRecord): Promise<RunRecord | undefined>;
+export declare function getWorkflowRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<RunRecord | undefined>;
+export declare function listWorkflowRuns(storage: WorkflowStorage, namespace: string, options?: ListRunsOptions): Promise<readonly RunRecord[]>;
+export declare function listWorkflowRunsPage(storage: WorkflowStorage, namespace: string, options?: ListRunsPageOptions): Promise<WorkflowPage<RunRecord>>;
+export declare function countWorkflowRuns(storage: WorkflowStorage, namespace: string, options?: ListRunsOptions): Promise<number>;
+export declare function updateWorkflowRun(storage: WorkflowStorage, namespace: string, store: RunReader, run: RunRecord): Promise<RunRecord>;
+export declare function claimWorkflowRun(storage: WorkflowStorage, namespace: string, store: RunClaimReader, options: ClaimRunOptions): Promise<RunRecord | undefined>;
+export declare function extendWorkflowRunLease(storage: WorkflowStorage, namespace: string, store: RunReader, 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: {
+}): Promise<RunRecord | undefined>;
+export declare function releaseWorkflowRunLease(storage: WorkflowStorage, namespace: string, store: RunReader, 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;
+}): Promise<RunRecord | undefined>;
+export declare function isStoredRunRevisionCurrent(storage: WorkflowStorage, namespace: string, currentRun: RunRecord): Promise<boolean>;
+export declare function getReadableStoredRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<RunRecord | undefined>;
+export declare function requireReadableStoredRun(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<RunRecord>;
+export declare function isRunStaleForAppend(currentRun: RunRecord, event: EventRecord): boolean;
+export declare function rollbackAppendedEventIfRunStale(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, events: readonly EventRecord[]): Promise<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 };
+export {};