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

package/dist/schema/store.mjs

@@ -0,0 +1,116 @@
+import { idSchema, nonBlankStringSchema, nonNegativeSafeIntegerSchema, positiveSafeIntegerSchema, temporalDurationSchema, temporalInstantSchema } from "./common.mjs";
+import { errorRecordSchema } from "./error.mjs";
+import { persistedValueIssue, persistedValueSchema } from "./persisted-value.mjs";
+import { childWorkflowCancellationPolicySchema, materializedStepTypeSchema, terminalRunStatusSchema } from "./run.mjs";
+import { ss } from "@temelj/standard-schema";
+//#region src/schema/store.ts
+const lockRecordSchema = ss.object({
+	key: nonBlankStringSchema,
+	namespace: nonBlankStringSchema,
+	holderId: nonBlankStringSchema,
+	holderRunId: ss.optional(idSchema),
+	holderStepId: ss.optional(idSchema),
+	fencingToken: positiveSafeIntegerSchema,
+	acquiredAt: temporalInstantSchema,
+	leaseExpiresAt: temporalInstantSchema,
+	releasedAt: ss.optional(temporalInstantSchema)
+});
+const cleanupModeSchema = ss.literal("best_effort");
+const cleanupMarkerRecordSchema = ss.object({
+	mode: cleanupModeSchema,
+	runId: idSchema,
+	workflowName: nonBlankStringSchema,
+	workflowVersion: ss.optional(nonBlankStringSchema),
+	status: terminalRunStatusSchema,
+	createdAt: temporalInstantSchema,
+	finishedAt: temporalInstantSchema,
+	cleanupStartedAt: temporalInstantSchema,
+	events: nonNegativeSafeIntegerSchema,
+	stepAttempts: nonNegativeSafeIntegerSchema,
+	idempotencyKeys: nonNegativeSafeIntegerSchema,
+	messageIdempotencyKeys: nonNegativeSafeIntegerSchema
+});
+const scheduleIdSchema = ss.refine(ss.string(), (value) => value.trim().length > 0, "Expected an ID");
+const scheduleStatusSchema = ss.picklist([
+	"active",
+	"paused",
+	"archived",
+	"deleted"
+]);
+const scheduleCatchUpPolicySchema = ss.picklist([
+	"skip",
+	"one",
+	"all"
+]);
+const scheduleOverlapPolicySchema = ss.picklist([
+	"allow",
+	"skip",
+	"buffer",
+	"cancel"
+]);
+const schedulePositiveDurationSchema = ss.refine(temporalDurationSchema, (value) => value.total({ unit: "millisecond" }) > 0, "Expected a positive duration");
+const scheduleRecordSchema = ss.object({
+	id: scheduleIdSchema,
+	namespace: nonBlankStringSchema,
+	workflowName: nonBlankStringSchema,
+	workflowVersion: ss.optional(nonBlankStringSchema),
+	input: ss.optional(persistedValueSchema),
+	context: ss.optional(persistedValueSchema),
+	status: scheduleStatusSchema,
+	every: schedulePositiveDurationSchema,
+	catchUp: scheduleCatchUpPolicySchema,
+	maxCatchUpRuns: ss.optional(positiveSafeIntegerSchema),
+	maxLateness: ss.optional(schedulePositiveDurationSchema),
+	overlap: scheduleOverlapPolicySchema,
+	createdAt: temporalInstantSchema,
+	updatedAt: temporalInstantSchema,
+	nextFireAt: temporalInstantSchema,
+	endAt: ss.optional(temporalInstantSchema),
+	bufferedFireAt: ss.optional(temporalInstantSchema),
+	lastFireAt: ss.optional(temporalInstantSchema),
+	lastRunId: ss.optional(idSchema),
+	tickCount: ss.union([positiveSafeIntegerSchema, ss.literal(0)])
+});
+const stepAttemptStatusSchema = ss.picklist([
+	"running",
+	"completed",
+	"failed",
+	"abandoned"
+]);
+const stepAttemptRecordSchema = ss.object({
+	runId: idSchema,
+	stepId: idSchema,
+	stepName: nonBlankStringSchema,
+	kind: materializedStepTypeSchema,
+	status: stepAttemptStatusSchema,
+	attempt: positiveSafeIntegerSchema,
+	count: ss.optional(positiveSafeIntegerSchema),
+	output: ss.optional(persistedValueSchema),
+	error: ss.optional(errorRecordSchema),
+	until: ss.optional(temporalInstantSchema),
+	duration: ss.optional(ss.instanceOf(Temporal.Duration, "Expected a Temporal.Duration")),
+	childRunId: ss.optional(idSchema),
+	workflowName: ss.optional(nonBlankStringSchema),
+	workflowVersion: ss.optional(nonBlankStringSchema),
+	cancellation: ss.optional(childWorkflowCancellationPolicySchema),
+	input: ss.optional(persistedValueSchema),
+	timeoutAt: ss.optional(temporalInstantSchema),
+	messageId: ss.optional(idSchema),
+	targetRunId: ss.optional(idSchema),
+	payload: ss.optional(persistedValueSchema),
+	messageTimestamp: ss.optional(temporalInstantSchema),
+	createdAt: temporalInstantSchema,
+	startedAt: temporalInstantSchema,
+	finishedAt: ss.optional(temporalInstantSchema)
+});
+const cleanupIndexKeySchema = ss.object({
+	key: nonBlankStringSchema,
+	value: ss.refine(persistedValueSchema, (value) => value !== void 0 && persistedValueIssue(value, "value", /* @__PURE__ */ new WeakSet(), true) === void 0, "Expected a storage value")
+});
+const messageIdempotencyIndexSchema = ss.object({
+	runId: idSchema,
+	messageId: idSchema,
+	timestamp: temporalInstantSchema
+});
+//#endregion
+export { cleanupIndexKeySchema, cleanupMarkerRecordSchema, cleanupModeSchema, lockRecordSchema, messageIdempotencyIndexSchema, scheduleRecordSchema, stepAttemptRecordSchema, stepAttemptStatusSchema };

package/dist/step-definition.d.mts

@@ -1,10 +1,5 @@
-import { WorkflowStepContext, WorkflowStepDefinition, WorkflowStepRunConfig } from "./types/step.mjs";
+import { StepDefinition, StepDefinitionHandler, StepRunConfig } from "./types/step.mjs";
 //#region src/step-definition.d.ts
-type WorkflowStepHandler = (...args: never[]) => unknown;
-type WorkflowStepHandlerInputTuple<THandler extends WorkflowStepHandler> = THandler extends ((...args: infer TArgs) => unknown) ? TArgs : never;
-type WorkflowStepHandlerArgs<THandler extends WorkflowStepHandler> = WorkflowStepHandlerInputTuple<THandler> extends [...infer TArgs, WorkflowStepContext] ? TArgs : WorkflowStepHandlerInputTuple<THandler>;
-type WorkflowStepHandlerOutput<THandler extends WorkflowStepHandler> = THandler extends ((...args: never[]) => infer TOutput) ? Awaited<TOutput> : never;
-/** Defines a workflow step. */
-declare function defineWorkflowStep<THandler extends WorkflowStepHandler>(config: WorkflowStepRunConfig, handler: THandler): WorkflowStepDefinition<WorkflowStepHandlerArgs<THandler>, WorkflowStepHandlerOutput<THandler>>;
-//#endregion
-export { defineWorkflowStep };
+/** Defines a durable step whose handler receives context before its typed arguments. */
+export declare function defineWorkflowStep<TArgs extends readonly unknown[], TOutput>(config: StepRunConfig, handler: StepDefinitionHandler<TArgs, TOutput>): StepDefinition<TArgs, TOutput>;
+//#endregion

package/dist/step-definition.mjs

@@ -1,10 +1,10 @@
 import { WorkflowDefinitionError } from "./errors/definition.mjs";
 import "./errors/mod.mjs";
 //#region src/step-definition.ts
-/** Defines a workflow step. */
+/** Defines a durable step whose handler receives context before its typed arguments. */
 function defineWorkflowStep(config, handler) {
 	const commandId = config.commandId ?? config.name;
-	if (commandId === void 0) WorkflowDefinitionError.stepNameOrCommandIdRequired();
+	if (commandId === void 0) throw new WorkflowDefinitionError("Workflow step name or commandId is required");
 	return {
 		config,
 		name: commandId,

package/dist/store/capabilities.d.mts

@@ -1,14 +1,13 @@
-import { WorkflowStorage, WorkflowStoreCapabilities } from "../types/store.mjs";
+import { StoreCapabilities, WorkflowStorage } from "../types/store.mjs";
 //#region src/store/capabilities.d.ts
 /** Detects which coordination capabilities are available on a workflow store backend. */
-declare function getWorkflowStoreCapabilities(storage: WorkflowStorage): WorkflowStoreCapabilities;
+export declare function getWorkflowStoreCapabilities(storage: WorkflowStorage): StoreCapabilities;
 /** Validates workflow store capabilities and throws when the requirement is not met. */
-declare function requireWorkflowStoreCapabilities(store: {
-  readonly capabilities: WorkflowStoreCapabilities;
-}, requirements: Partial<Record<keyof WorkflowStoreCapabilities, string>>): void;
+export declare function requireStoreCapabilities(store: {
+  readonly capabilities: StoreCapabilities;
+}, requirements: readonly (readonly [capability: keyof StoreCapabilities, label: string])[]): void;
 /** Returns whether a storage backend can reject stale single-key writes. */
-declare function supportsWorkflowConditionalWrite(storage: WorkflowStorage): boolean;
+export declare function supportsConditionalWrite(storage: WorkflowStorage): boolean;
 /** Returns whether a storage backend can atomically reject stale multi-key writes. */
-declare function supportsWorkflowAtomicBatchWrite(storage: WorkflowStorage): boolean;
-//#endregion
-export { getWorkflowStoreCapabilities, requireWorkflowStoreCapabilities, supportsWorkflowAtomicBatchWrite, supportsWorkflowConditionalWrite };
+export declare function supportsAtomicBatchWrite(storage: WorkflowStorage): boolean;
+//#endregion

package/dist/store/capabilities.mjs

@@ -3,8 +3,8 @@ import "../errors/mod.mjs";
 //#region src/store/capabilities.ts
 /** Detects which coordination capabilities are available on a workflow store backend. */
 function getWorkflowStoreCapabilities(storage) {
-	const conditionalWrites = supportsWorkflowConditionalWrite(storage);
-	const conditionalBatches = supportsWorkflowAtomicBatchWrite(storage);
+	const conditionalWrites = supportsConditionalWrite(storage);
+	const conditionalBatches = supportsAtomicBatchWrite(storage);
 	return {
 		conditionalWrites,
 		conditionalRunClaims: conditionalWrites,
@@ -27,16 +27,16 @@ function getWorkflowStoreCapabilities(storage) {
 	};
 }
 /** Validates workflow store capabilities and throws when the requirement is not met. */
-function requireWorkflowStoreCapabilities(store, requirements) {
-	for (const [capability, label] of Object.entries(requirements)) if (store.capabilities[capability] !== true) WorkflowCapabilityError.unsupported(label ?? `workflow store ${capability}`);
+function requireStoreCapabilities(store, requirements) {
+	for (const [capability, label] of requirements) if (store.capabilities[capability] !== true) WorkflowCapabilityError.unsupported(label ?? `workflow store ${capability}`);
 }
 /** Returns whether a storage backend can reject stale single-key writes. */
-function supportsWorkflowConditionalWrite(storage) {
+function supportsConditionalWrite(storage) {
 	return storage.capabilities.compareAndSet;
 }
 /** Returns whether a storage backend can atomically reject stale multi-key writes. */
-function supportsWorkflowAtomicBatchWrite(storage) {
+function supportsAtomicBatchWrite(storage) {
 	return storage.capabilities.compareAndSetMany;
 }
 //#endregion
-export { getWorkflowStoreCapabilities, requireWorkflowStoreCapabilities, supportsWorkflowAtomicBatchWrite, supportsWorkflowConditionalWrite };
+export { getWorkflowStoreCapabilities, requireStoreCapabilities, supportsAtomicBatchWrite, supportsConditionalWrite };

package/dist/store/cleanup.d.mts

@@ -1,18 +1,13 @@
-import { RunId } from "../types/run-id.mjs";
 import { CleanupMarkerRecord, CleanupRunsOptions, CleanupRunsResult } from "../types/cleanup.mjs";
-import { WorkflowListRunsOptions } from "../types/run-list.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowCleanupIndexKey, WorkflowStorage } from "../types/store.mjs";
+import { ListRunsOptions } from "../types/run-list.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { CleanupIndexKey, WorkflowStorage } from "../types/store.mjs";
 //#region src/store/cleanup.d.ts
-interface WorkflowCleanupRunLister {
-  listRuns(options: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
+interface CleanupRunLister {
+  listRuns(options: ListRunsOptions): Promise<readonly RunRecord[]>;
 }
-declare function stepAttemptKeysForCleanup(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly string[]>;
-declare function messageIdempotencyIndexesForCleanup(storage: WorkflowStorage, namespace: string, runId: RunId, events: readonly EventRecord[]): Promise<readonly WorkflowCleanupIndexKey[]>;
-declare function idempotencyIndexesForCleanup(storage: WorkflowStorage, namespace: string, run: WorkflowRunRecord): Promise<readonly WorkflowCleanupIndexKey[]>;
-declare function deleteCleanupIndexes(storage: WorkflowStorage, indexes: readonly WorkflowCleanupIndexKey[]): Promise<number>;
-declare function cleanupRuns(storage: WorkflowStorage, namespace: string, runs: WorkflowCleanupRunLister, options: CleanupRunsOptions): Promise<CleanupRunsResult>;
-declare function listCleanupMarkers(storage: WorkflowStorage, namespace: string): Promise<readonly CleanupMarkerRecord[]>;
+export declare function deleteCleanupIndexes(storage: WorkflowStorage, indexes: readonly CleanupIndexKey[]): Promise<number>;
+export declare function cleanupRuns(storage: WorkflowStorage, namespace: string, runs: CleanupRunLister, options: CleanupRunsOptions): Promise<CleanupRunsResult>;
+export declare function listCleanupMarkers(storage: WorkflowStorage, namespace: string): Promise<readonly CleanupMarkerRecord[]>;
 //#endregion
-export { cleanupRuns, deleteCleanupIndexes, idempotencyIndexesForCleanup, listCleanupMarkers, messageIdempotencyIndexesForCleanup, stepAttemptKeysForCleanup };
+export {};

package/dist/store/cleanup.mjs

@@ -1,16 +1,17 @@
+import { compareOptionalTimestamps } from "../temporal.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
-import { isTerminalWorkflowRunStatus } from "../utility.mjs";
 import "../errors/mod.mjs";
-import { omitUndefined } from "../collection.mjs";
-import { compareOptionalTimestamps } from "../temporal.mjs";
-import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
+import { omitUndefined, uniqueBy } from "../collection.mjs";
 import { isStepAttemptKey, makeCleanupMarkerKey, makeCleanupMarkerKeyPrefix, makeEventsKey, makeIdempotencyKey, makeMessageIdempotencyKey, makeRunKey, makeStepAttemptKeyPrefix } from "../store-keys.mjs";
-import { isSameWorkflowStorageValue } from "./revision.mjs";
+import { isTerminalRunStatus } from "../run-status.mjs";
+import { supportsConditionalWrite } from "./capabilities.mjs";
 import { toStorageValue } from "./storage-value.mjs";
 import { isReadableMessageIdempotencyIndex, isSameMessageIdempotencyIndex, readableCleanupMarkerRecord } from "./validation.mjs";
-import { getStoredCleanupEventHistory } from "./event-history.mjs";
-import { getReadableStoredWorkflowRun } from "./run.mjs";
-import { messageIdempotencyIndexValuesFromEvents } from "./message-index.mjs";
+import { getReadableStoredRun } from "./run.mjs";
+import { messageIdempotencyIndexValuesFromEvents } from "./indexes.mjs";
+import { getStoredCleanupEventHistory } from "./events.mjs";
+import { deepEquals } from "@temelj/value";
 //#region src/store/cleanup.ts
 async function stepAttemptKeysForCleanup(storage, namespace, runId) {
 	const prefix = makeStepAttemptKeyPrefix(namespace, runId);
@@ -34,19 +35,19 @@ async function idempotencyIndexesForCleanup(storage, namespace, run) {
 	}] : [];
 }
 async function deleteCleanupIndexes(storage, indexes) {
-	const uniqueIndexes = indexes.filter(uniqueCleanupIndexKey);
-	if (!supportsWorkflowConditionalWrite(storage)) {
+	const uniqueIndexes = uniqueBy(indexes, (index) => index.key);
+	if (!supportsConditionalWrite(storage)) {
 		const currentIndexes = await Promise.all(uniqueIndexes.map(async (index) => ({
 			...index,
 			current: await storage.get(index.key)
 		})));
 		return await storage.deleteMany(currentIndexes.flatMap((index) => workflowCleanupIndexMatchesCurrentValue(index.current, index.value) ? [index.key] : []));
 	}
-	return (await Promise.all(uniqueIndexes.map(async (index) => await storage.compareAndSet(index.key, index.value, void 0)))).filter((value) => value).length;
+	return (await Promise.all(uniqueIndexes.map((index) => storage.compareAndSet(index.key, index.value, void 0)))).filter((value) => value).length;
 }
 function workflowCleanupIndexMatchesCurrentValue(current, expected) {
 	if (isReadableMessageIdempotencyIndex(expected)) return isSameMessageIdempotencyIndex(current, expected);
-	return isSameWorkflowStorageValue(current, expected);
+	return deepEquals(current, expected);
 }
 function messageIdempotencyIndexesFromEvents(namespace, runId, events) {
 	return messageIdempotencyIndexValuesFromEvents(events, runId).map(({ idempotencyKey, value }) => ({
@@ -55,12 +56,16 @@ function messageIdempotencyIndexesFromEvents(namespace, runId, events) {
 	}));
 }
 function idempotencyKeyFromRun(namespace, run) {
-	if (run.idempotencyKey === void 0) WorkflowStateError.runMissingIdempotencyKey(run.id);
-	return makeIdempotencyKey(namespace, {
+	if (run.idempotencyKey === void 0) throw new WorkflowStateError(`Workflow run does not have an idempotency key: ${run.id}`, {
+		code: WorkflowErrorCode.STATE_RUN_MISSING_IDEMPOTENCY_KEY,
+		details: { runId: run.id }
+	});
+	const options = {
 		workflowName: run.workflowName,
-		...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion },
+		workflowVersion: run.workflowVersion,
 		idempotencyKey: run.idempotencyKey
-	});
+	};
+	return makeIdempotencyKey(namespace, options);
 }
 function toCleanupIndex(entry) {
 	return {
@@ -72,28 +77,24 @@ function isCurrentMessageIdempotencyIndex(eventIndexes, value) {
 	if (!isReadableMessageIdempotencyIndex(value)) return false;
 	return eventIndexes.some((eventIndex) => isSameMessageIdempotencyIndex(value, eventIndex.value));
 }
-function uniqueCleanupIndexKey(index, position, indexes) {
-	return indexes.findIndex((current) => current.key === index.key) === position;
-}
 async function cleanupRuns(storage, namespace, runs, options) {
-	const cleanupOptions = options;
-	const limit = cleanupOptions.limit;
-	const statusFilter = cleanupOptions.status ?? [
+	const limit = options.limit;
+	const statusFilter = options.status ?? [
 		"completed",
 		"failed",
 		"canceled"
 	];
-	const selectedRuns = (await runs.listRuns({
+	const selectedRuns = uniqueBy((await runs.listRuns({
 		status: Array.isArray(statusFilter) ? [...statusFilter] : statusFilter,
-		workflowName: cleanupOptions.workflowName,
-		workflowVersion: cleanupOptions.workflowVersion,
-		idempotencyKey: cleanupOptions.idempotencyKey,
-		parentRunId: cleanupOptions.parentRunId,
-		parentStepId: cleanupOptions.parentStepId,
-		parentStepName: cleanupOptions.parentStepName,
-		parentStepAttempt: cleanupOptions.parentStepAttempt
-	})).filter((run) => isWorkflowRunEligibleForCleanup(run, cleanupOptions)).sort(compareCleanupRuns).filter(isFirstCleanupRunForId).slice(0, limit);
-	const stepAttemptKeysByRun = await Promise.all(selectedRuns.map(async (run) => await stepAttemptKeysForCleanup(storage, namespace, run.id)));
+		workflowName: options.workflowName,
+		workflowVersion: options.workflowVersion,
+		idempotencyKey: options.idempotencyKey,
+		parentRunId: options.parentRunId,
+		parentStepId: options.parentStepId,
+		parentStepName: options.parentStepName,
+		parentStepAttempt: options.parentStepAttempt
+	})).filter((run) => isRunEligibleForCleanup(run, options)).sort(compareCleanupRuns), (run) => run.id).slice(0, limit);
+	const stepAttemptKeysByRun = await Promise.all(selectedRuns.map((run) => stepAttemptKeysForCleanup(storage, namespace, run.id)));
 	const stepAttemptKeys = stepAttemptKeysByRun.flat();
 	const eventKeysByRun = selectedRuns.map((run) => makeEventsKey(namespace, run.id));
 	const storedEventsByRun = await Promise.all(eventKeysByRun.map(async (key) => {
@@ -110,13 +111,13 @@ async function cleanupRuns(storage, namespace, runs, options) {
 		key: makeRunKey(namespace, run.id),
 		run
 	}));
-	const idempotencyIndexesByRun = await Promise.all(selectedRuns.map(async (run) => await idempotencyIndexesForCleanup(storage, namespace, run)));
+	const idempotencyIndexesByRun = await Promise.all(selectedRuns.map((run) => idempotencyIndexesForCleanup(storage, namespace, run)));
 	const idempotencyKeysByRun = idempotencyIndexesByRun.map((indexes) => indexes.map((index) => index.key));
 	const idempotencyKeys = idempotencyKeysByRun.flat();
-	const messageIdempotencyIndexesByRun = await Promise.all(selectedRuns.map(async (run, index) => await messageIdempotencyIndexesForCleanup(storage, namespace, run.id, runEvents[index] ?? [])));
+	const messageIdempotencyIndexesByRun = await Promise.all(selectedRuns.map((run, index) => messageIdempotencyIndexesForCleanup(storage, namespace, run.id, runEvents[index] ?? [])));
 	const messageIdempotencyKeysByRun = messageIdempotencyIndexesByRun.map((indexes) => indexes.map((index) => index.key));
 	const messageIdempotencyKeys = messageIdempotencyKeysByRun.flat();
-	const deletionResults = cleanupOptions.dryRun === true ? selectedRuns.map(() => ({
+	const deletionResults = options.dryRun === true ? selectedRuns.map(() => ({
 		cleanupMarkerCreated: false,
 		cleanupMarkerDeleted: false,
 		runDeleted: false,
@@ -142,42 +143,42 @@ async function cleanupRuns(storage, namespace, runs, options) {
 	return {
 		mode: "best_effort",
 		runIds: selectedRuns.map((run) => run.id),
-		runs: selectedRuns.map((run, index) => ({
-			mode: "best_effort",
-			runId: run.id,
-			workflowName: run.workflowName,
-			...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion },
-			status: isTerminalWorkflowRunStatus(run.status) ? run.status : (() => {
-				WorkflowStateError.cleanupSelectedNonTerminalRun(run.id);
-			})(),
-			createdAt: run.createdAt,
-			updatedAt: run.updatedAt,
-			finishedAt: cleanupFinishedAt(run),
-			...run.idempotencyKey === void 0 ? {} : { idempotencyKey: run.idempotencyKey },
-			...run.parentRunId === void 0 ? {} : { parentRunId: run.parentRunId },
-			...run.parentStepId === void 0 ? {} : { parentStepId: run.parentStepId },
-			...run.parentStepName === void 0 ? {} : { parentStepName: run.parentStepName },
-			...run.parentStepAttempt === void 0 ? {} : { parentStepAttempt: run.parentStepAttempt },
-			events: runEvents[index]?.length ?? 0,
-			stepAttempts: stepAttemptKeysByRun[index]?.length ?? 0,
-			idempotencyKeys: idempotencyKeysByRun[index]?.length ?? 0,
-			messageIdempotencyKeys: messageIdempotencyKeysByRun[index]?.length ?? 0,
-			cleanupMarkerCreated: deletionResults[index]?.cleanupMarkerCreated ?? false,
-			cleanupMarkerDeleted: deletionResults[index]?.cleanupMarkerDeleted ?? false,
-			runDeleted: deletionResults[index]?.runDeleted ?? false,
-			deletedEvents: deletionResults[index]?.deletedEvents ?? 0,
-			deletedStepAttempts: deletionResults[index]?.deletedStepAttempts ?? 0,
-			deletedIdempotencyKeys: deletionResults[index]?.deletedIdempotencyKeys ?? 0,
-			deletedMessageIdempotencyKeys: deletionResults[index]?.deletedMessageIdempotencyKeys ?? 0
-		})),
-		...cleanupOptions.dryRun === true ? {
-			dryRun: true,
-			matchedRuns: selectedRuns.length,
-			matchedEvents: eventKeys.length,
-			matchedStepAttempts: stepAttemptKeys.length,
-			matchedIdempotencyKeys: idempotencyKeys.length,
-			matchedMessageIdempotencyKeys: messageIdempotencyKeys.length
-		} : {},
+		runs: selectedRuns.map((run, index) => {
+			return {
+				mode: "best_effort",
+				runId: run.id,
+				workflowName: run.workflowName,
+				workflowVersion: run.workflowVersion,
+				status: isTerminalRunStatus(run.status) ? run.status : (() => {
+					WorkflowStateError.cleanupSelectedNonTerminalRun(run.id);
+				})(),
+				createdAt: run.createdAt,
+				updatedAt: run.updatedAt,
+				finishedAt: cleanupFinishedAt(run),
+				idempotencyKey: run.idempotencyKey,
+				parentRunId: run.parentRunId,
+				parentStepId: run.parentStepId,
+				parentStepName: run.parentStepName,
+				parentStepAttempt: run.parentStepAttempt,
+				events: runEvents[index]?.length ?? 0,
+				stepAttempts: stepAttemptKeysByRun[index]?.length ?? 0,
+				idempotencyKeys: idempotencyKeysByRun[index]?.length ?? 0,
+				messageIdempotencyKeys: messageIdempotencyKeysByRun[index]?.length ?? 0,
+				cleanupMarkerCreated: deletionResults[index]?.cleanupMarkerCreated ?? false,
+				cleanupMarkerDeleted: deletionResults[index]?.cleanupMarkerDeleted ?? false,
+				runDeleted: deletionResults[index]?.runDeleted ?? false,
+				deletedEvents: deletionResults[index]?.deletedEvents ?? 0,
+				deletedStepAttempts: deletionResults[index]?.deletedStepAttempts ?? 0,
+				deletedIdempotencyKeys: deletionResults[index]?.deletedIdempotencyKeys ?? 0,
+				deletedMessageIdempotencyKeys: deletionResults[index]?.deletedMessageIdempotencyKeys ?? 0
+			};
+		}),
+		dryRun: options.dryRun === true ? true : void 0,
+		matchedRuns: options.dryRun === true ? selectedRuns.length : void 0,
+		matchedEvents: options.dryRun === true ? eventKeys.length : void 0,
+		matchedStepAttempts: options.dryRun === true ? stepAttemptKeys.length : void 0,
+		matchedIdempotencyKeys: options.dryRun === true ? idempotencyKeys.length : void 0,
+		matchedMessageIdempotencyKeys: options.dryRun === true ? messageIdempotencyKeys.length : void 0,
 		deletedRuns,
 		createdCleanupMarkers,
 		deletedCleanupMarkers,
@@ -189,7 +190,7 @@ async function cleanupRuns(storage, namespace, runs, options) {
 }
 async function listCleanupMarkers(storage, namespace) {
 	const prefix = makeCleanupMarkerKeyPrefix(namespace);
-	return (await Promise.all((await storage.keys({ prefix })).filter((key) => isCleanupMarkerKey(key, prefix)).map(async (key) => await storage.get(key)))).flatMap((marker) => {
+	return (await Promise.all((await storage.keys({ prefix })).filter((key) => isCleanupMarkerKey(key, prefix)).map((key) => storage.get(key)))).flatMap((marker) => {
 		const parsed = readableCleanupMarkerRecord(marker);
 		return parsed === void 0 ? [] : [parsed];
 	}).sort(compareCleanupMarkers);
@@ -207,11 +208,14 @@ function countCleanupDeletionResult(results, key) {
 	return results.filter((result) => result[key]).length;
 }
 function cleanupFinishedAt(run) {
-	if (run.finishedAt === void 0) WorkflowStateError.cleanupRunMissingFinishedAt(run.id);
+	if (run.finishedAt === void 0) throw new WorkflowStateError(`Workflow cleanup run is missing finishedAt: ${run.id}`, {
+		code: WorkflowErrorCode.STATE_CLEANUP_RUN_MISSING_FINISHED_AT,
+		details: { runId: run.id }
+	});
 	return run.finishedAt;
 }
-function isWorkflowRunEligibleForCleanup(run, options) {
-	if (!isTerminalWorkflowRunStatus(run.status) || run.finishedAt === void 0) return false;
+function isRunEligibleForCleanup(run, options) {
+	if (!isTerminalRunStatus(run.status) || run.finishedAt === void 0) return false;
 	if (Temporal.Instant.compare(run.finishedAt, options.finishedAtBefore) >= 0) return false;
 	return options.status === void 0 || matchesCleanupStatus(run.status, options.status);
 }
@@ -225,9 +229,6 @@ function compareCleanupRuns(left, right) {
 	if (createdOrder !== 0) return createdOrder;
 	return left.id.localeCompare(right.id);
 }
-function isFirstCleanupRunForId(run, index, runs) {
-	return runs.findIndex((entry) => entry.id === run.id) === index;
-}
 async function deleteCleanupRunsAndArtifacts(storage, options) {
 	const markers = await createCleanupMarkers(storage, options);
 	const deletedRuns = await deleteCleanupRunRecords(storage, options.runs);
@@ -279,8 +280,8 @@ async function createCleanupMarkers(storage, options) {
 			mode: "best_effort",
 			runId: run.id,
 			workflowName: run.workflowName,
-			...run.workflowVersion === void 0 ? {} : { workflowVersion: run.workflowVersion },
-			status: isTerminalWorkflowRunStatus(run.status) ? run.status : (() => {
+			workflowVersion: run.workflowVersion,
+			status: isTerminalRunStatus(run.status) ? run.status : (() => {
 				WorkflowStateError.cleanupSelectedNonTerminalRun(run.id);
 			})(),
 			createdAt: run.createdAt,
@@ -302,14 +303,14 @@ function deletionCompleted(options) {
 	return options.deletedEvents === options.expectedEvents && options.deletedStepAttempts === options.expectedStepAttempts && options.deletedIdempotencyKeys === options.expectedIdempotencyKeys && options.deletedMessageIdempotencyKeys === options.expectedMessageIdempotencyKeys;
 }
 async function deleteCleanupRunRecords(storage, runs) {
-	if (!supportsWorkflowConditionalWrite(storage)) {
+	if (!supportsConditionalWrite(storage)) {
 		const deletedRuns = (await Promise.all(runs.map(async (run) => {
-			return await getReadableStoredWorkflowRun(storage, run.run.namespace, run.run.id);
-		}))).map((latest, index) => latest !== void 0 && isSameWorkflowStorageValue(omitUndefined(latest), omitUndefined(runs[index].run)));
+			return await getReadableStoredRun(storage, run.run.namespace, run.run.id);
+		}))).map((latest, index) => latest !== void 0 && deepEquals(omitUndefined(latest), omitUndefined(runs[index].run)));
 		await storage.deleteMany(runs.flatMap((run, index) => deletedRuns[index] === true ? [run.key] : []));
 		return deletedRuns;
 	}
-	return await Promise.all(runs.map(async (run) => await storage.compareAndSet(run.key, toStorageValue(run.run), void 0)));
+	return await Promise.all(runs.map((run) => storage.compareAndSet(run.key, toStorageValue(run.run), void 0)));
 }
 //#endregion
-export { cleanupRuns, deleteCleanupIndexes, idempotencyIndexesForCleanup, listCleanupMarkers, messageIdempotencyIndexesForCleanup, stepAttemptKeysForCleanup };
+export { cleanupRuns, deleteCleanupIndexes, listCleanupMarkers };

package/dist/store/create.d.mts

@@ -1,52 +1,51 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.mjs";
 import { CleanupMarkerRecord, CleanupRunsOptions, CleanupRunsResult } from "../types/cleanup.mjs";
 import { WorkflowPage } from "../types/pagination.mjs";
 import { ListSchedulesOptions, ListSchedulesPageOptions, ScheduleRecord } from "../types/schedule.mjs";
 import { LockRecord } from "../types/lock.mjs";
-import { WorkflowListRunsOptions, WorkflowListRunsPageOptions, WorkflowListStepAttemptsPageOptions } from "../types/run-list.mjs";
-import { WorkflowListStepAttemptsOptions, WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
+import { ListRunsOptions, ListRunsPageOptions, ListStepAttemptsPageOptions } from "../types/run-list.mjs";
+import { ListStepAttemptsOptions, StepAttemptRecord } from "../types/step-attempts.mjs";
+import { RunRecord } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { CreateWorkflowStoreOptions, WorkflowClaimRunOptions, WorkflowEventHistoryChangeWaitOptions, WorkflowExtendRunLeaseOptions, WorkflowIdempotencyKeyOptions, WorkflowMessageIdempotencyIndex, WorkflowReleaseRunLeaseOptions, WorkflowStorage, WorkflowStore as WorkflowStore$1, WorkflowStoreCapabilities } from "../types/store.mjs";
+import { ClaimRunOptions, CreateWorkflowStoreOptions, ExtendRunLeaseOptions, IdempotencyKeyOptions, MessageIdempotencyIndex, ReleaseRunLeaseOptions, StoreCapabilities, WorkflowEventHistoryChangeWaitOptions, WorkflowStorage, WorkflowStore as WorkflowStore$1 } from "../types/store.mjs";
 //#region src/store/create.d.ts
-declare function createWorkflowStore(options?: CreateWorkflowStoreOptions): WorkflowStore$1;
+export declare function createWorkflowStore(options?: CreateWorkflowStoreOptions): WorkflowStore$1;
 /** Storage-backed workflow store implementation. */
-declare class WorkflowStore implements WorkflowStore$1 {
+export declare class WorkflowStore implements WorkflowStore$1 {
   readonly storage: WorkflowStorage;
   readonly namespace: string;
-  readonly capabilities: WorkflowStoreCapabilities;
+  readonly capabilities: StoreCapabilities;
   constructor(options?: CreateWorkflowStoreOptions);
-  createRun(run: WorkflowRunRecord): Promise<WorkflowRunRecord>;
-  getRun(runId: RunId): Promise<WorkflowRunRecord | undefined>;
-  getRunByIdempotencyKey(options: WorkflowIdempotencyKeyOptions): Promise<WorkflowRunRecord | undefined>;
-  updateRun(run: WorkflowRunRecord): Promise<WorkflowRunRecord>;
-  updateRunIfCurrent(current: WorkflowRunRecord, next: WorkflowRunRecord): Promise<WorkflowRunRecord | undefined>;
-  listRuns(options?: WorkflowListRunsOptions): Promise<readonly WorkflowRunRecord[]>;
-  listRunsPage(options?: WorkflowListRunsPageOptions): Promise<WorkflowPage<WorkflowRunRecord>>;
-  countRuns(options?: WorkflowListRunsOptions): Promise<number>;
-  claimRun(options: WorkflowClaimRunOptions): Promise<WorkflowRunRecord | undefined>;
-  extendRunLease(options: WorkflowExtendRunLeaseOptions): Promise<WorkflowRunRecord | undefined>;
-  releaseRunLease(options: WorkflowReleaseRunLeaseOptions): Promise<WorkflowRunRecord | undefined>;
+  createRun(run: RunRecord): Promise<RunRecord>;
+  getRun(runId: RunId): Promise<RunRecord | undefined>;
+  getRunByIdempotencyKey(options: IdempotencyKeyOptions): Promise<RunRecord | undefined>;
+  updateRun(run: RunRecord): Promise<RunRecord>;
+  updateRunIfCurrent(current: RunRecord, next: RunRecord): Promise<RunRecord | undefined>;
+  listRuns(options?: ListRunsOptions): Promise<readonly RunRecord[]>;
+  listRunsPage(options?: ListRunsPageOptions): Promise<WorkflowPage<RunRecord>>;
+  countRuns(options?: ListRunsOptions): Promise<number>;
+  claimRun(options: ClaimRunOptions): Promise<RunRecord | undefined>;
+  extendRunLease(options: ExtendRunLeaseOptions): Promise<RunRecord | undefined>;
+  releaseRunLease(options: ReleaseRunLeaseOptions): Promise<RunRecord | undefined>;
   appendEvent(runId: RunId, event: EventRecord): Promise<readonly EventRecord[]>;
-  appendEventIfRunCurrent(current: WorkflowRunRecord, event: EventRecord): Promise<readonly EventRecord[] | undefined>;
+  appendEventIfRunCurrent(current: RunRecord, event: EventRecord): Promise<readonly EventRecord[] | undefined>;
   getEvents(runId: RunId): Promise<readonly EventRecord[]>;
   waitForEventHistoryChange(runId: RunId, options?: WorkflowEventHistoryChangeWaitOptions): Promise<void>;
-  listStepAttempts(runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<readonly WorkflowStepAttemptRecord[]>;
-  listStepAttemptsPage(runId: RunId, options?: WorkflowListStepAttemptsPageOptions): Promise<WorkflowPage<WorkflowStepAttemptRecord>>;
-  countStepAttempts(runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<number>;
-  repairStepAttempts(runId: RunId): Promise<readonly WorkflowStepAttemptRecord[]>;
-  repairMessageIdempotencyIndexes(runId: RunId): Promise<readonly WorkflowMessageIdempotencyIndex[]>;
+  listStepAttempts(runId: RunId, options?: ListStepAttemptsOptions): Promise<readonly StepAttemptRecord[]>;
+  listStepAttemptsPage(runId: RunId, options?: ListStepAttemptsPageOptions): Promise<WorkflowPage<StepAttemptRecord>>;
+  countStepAttempts(runId: RunId, options?: ListStepAttemptsOptions): Promise<number>;
+  repairStepAttempts(runId: RunId): Promise<readonly StepAttemptRecord[]>;
+  repairMessageIdempotencyIndexes(runId: RunId): Promise<readonly MessageIdempotencyIndex[]>;
   hasMessageIdempotencyKey(runId: RunId, idempotencyKey: string): Promise<boolean>;
   cleanupRuns(options: CleanupRunsOptions): Promise<CleanupRunsResult>;
   listCleanupMarkers(): Promise<readonly CleanupMarkerRecord[]>;
-  createSchedule<TInput>(schedule: ScheduleRecord<TInput>): Promise<ScheduleRecord<TInput>>;
+  createSchedule(schedule: ScheduleRecord): Promise<ScheduleRecord>;
   getSchedule(scheduleId: string): Promise<ScheduleRecord | undefined>;
-  updateScheduleIfCurrent<TInput>(current: ScheduleRecord, next: ScheduleRecord<TInput>): Promise<ScheduleRecord<TInput> | undefined>;
+  updateScheduleIfCurrent(current: ScheduleRecord, next: ScheduleRecord): Promise<ScheduleRecord | undefined>;
   listSchedules(options?: ListSchedulesOptions): Promise<readonly ScheduleRecord[]>;
   listSchedulesPage(options?: ListSchedulesPageOptions): Promise<WorkflowPage<ScheduleRecord>>;
   getLock(key: string): Promise<LockRecord | undefined>;
   listLocks(): Promise<readonly LockRecord[]>;
   updateLockIfCurrent(current: LockRecord | undefined, next: LockRecord): Promise<LockRecord | undefined>;
 }
-//#endregion
-export { WorkflowStore, createWorkflowStore };
+//#endregion