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

package/dist/store/run.mjs

@@ -1,59 +1,65 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import { WorkflowRunNotFoundError } from "../errors/run.mjs";
-import { isTerminalWorkflowLifecycleEventForRun, isTerminalWorkflowRunStatus, limitWorkflowItems, nextRunAttempt } from "../utility.mjs";
 import "../errors/mod.mjs";
-import { omitUndefined } from "../collection.mjs";
-import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
+import { limitItems, omitUndefined } from "../collection.mjs";
 import { makeRunKey } from "../store-keys.mjs";
-import { isSameWorkflowStorageValue } from "./revision.mjs";
+import { CLEARED_LEASE, CLEARED_RETRY, UNFINISHED, isTerminalEventForRun, isTerminalRunStatus, nextRunAttempt } from "../run-status.mjs";
+import { supportsConditionalWrite } from "./capabilities.mjs";
+import { makeRunCursorKey, pageItems } from "../pagination.mjs";
 import { toStorageValue } from "./storage-value.mjs";
-import { isReadableWorkflowRunRecord, parseStoredWorkflowRunRecord, requireReadableStoreRun, requireValidRunTransition } from "./validation.mjs";
-import { rollbackAppendedEventIfCurrent } from "./event-history.mjs";
-import { makeWorkflowRunCursorKey, pageItems } from "../pagination.mjs";
-import { compactWorkflowStoreRecord } from "./compaction.mjs";
-import { matchesWorkflowRunListOptions, queryWorkflowRuns } from "./query.mjs";
+import { isReadableRunRecord, parseStoredRunRecord, requireReadableStoreRun, requireValidRunTransition } from "./validation.mjs";
+import { rollbackAppendedEventIfCurrent } from "./events.mjs";
+import { matchesRunListOptions, queryRuns } from "./query.mjs";
+import { deepEquals } from "@temelj/value";
 //#region src/store/run.ts
 async function updateRunIfCurrent(storage, namespace, store, current, next) {
 	const runId = current.id;
 	const nextRunId = next.id;
-	if (runId !== nextRunId) WorkflowStateError.runIdMismatch(runId, nextRunId);
+	if (runId !== nextRunId) throw new WorkflowStateError(`Workflow store runId mismatch: ${runId} !== ${nextRunId}`, {
+		code: WorkflowErrorCode.STATE_RUN_ID_MISMATCH,
+		details: {
+			actual: runId,
+			expected: nextRunId
+		}
+	});
 	requireReadableStoreRun(current, namespace);
 	if (next.namespace !== namespace) WorkflowStateError.runNamespaceMismatch(String(next.namespace), namespace);
-	if (!supportsWorkflowConditionalWrite(storage)) {
+	if (!supportsConditionalWrite(storage)) {
 		const latest = await store.getRun(runId);
-		if (latest === void 0 || !isSameWorkflowStorageValue(omitUndefined(latest), omitUndefined(current))) return;
+		if (latest === void 0 || !deepEquals(omitUndefined(latest), omitUndefined(current))) return;
 		requireValidRunTransition(current, next);
-		const compact = compactWorkflowStoreRecord(next);
+		const compact = omitUndefined(next);
 		await storage.set(makeRunKey(namespace, runId), toStorageValue(compact));
 		return compact;
 	}
 	requireValidRunTransition(current, next);
-	const compact = compactWorkflowStoreRecord(next);
+	const compact = omitUndefined(next);
 	return await storage.compareAndSet(makeRunKey(namespace, runId), toStorageValue(current), toStorageValue(compact)) ? compact : void 0;
 }
 async function getWorkflowRun(storage, namespace, runId) {
 	const run = await storage.get(makeRunKey(namespace, runId));
-	return isReadableWorkflowRunRecord(run, namespace) ? run : void 0;
+	return isReadableRunRecord(run, namespace) ? run : void 0;
 }
 async function listWorkflowRuns(storage, namespace, options) {
-	const runs = await queryWorkflowRuns(storage, namespace, options, {
+	const runs = await queryRuns(storage, namespace, options, {
 		label: "Workflow run list options",
 		sort: true
 	});
-	return limitWorkflowItems(runs, options?.limit);
+	return limitItems(runs, options?.limit);
 }
 async function listWorkflowRunsPage(storage, namespace, options) {
-	const runs = await queryWorkflowRuns(storage, namespace, {
+	const runs = await queryRuns(storage, namespace, {
 		...options,
 		limit: void 0
 	}, {
 		label: "Workflow run page options",
 		sort: true
 	});
-	return pageItems(runs, options, "Workflow run page", makeWorkflowRunCursorKey);
+	return pageItems(runs, options, "Workflow run page", makeRunCursorKey);
 }
 async function countWorkflowRuns(storage, namespace, options) {
-	return (await queryWorkflowRuns(storage, namespace, options, {
+	return (await queryRuns(storage, namespace, options, {
 		label: "Workflow run list options",
 		sort: false
 	})).length;
@@ -63,147 +69,100 @@ async function updateWorkflowRun(storage, namespace, store, run) {
 	if (run.namespace !== namespace) WorkflowStateError.runNamespaceMismatch(String(run.namespace), namespace);
 	const current = await store.getRun(runId);
 	if (current !== void 0) requireValidRunTransition(current, run);
-	const compact = compactWorkflowStoreRecord(run);
+	const compact = omitUndefined(run);
 	await storage.set(makeRunKey(namespace, runId), toStorageValue(compact));
 	return compact;
 }
 async function claimWorkflowRun(storage, namespace, store, options) {
-	const listOptions = claimableWorkflowRunListOptions(options);
+	const listOptions = claimableRunListOptions(options);
 	const run = options.runId === void 0 ? await firstClaimableRun(store, options, listOptions) : await store.getRun(options.runId);
 	if (run === void 0 || !canClaimRun(run, options, listOptions)) return;
 	return await updateRunIfCurrent(storage, namespace, store, run, claimedRunPatch(run, options.workerId, options.now, options.leaseDuration));
 }
 async function extendWorkflowRunLease(storage, namespace, store, options) {
 	const run = await store.getRun(options.runId);
-	if (!isWorkflowRunLeaseHeldByWorker(run, options)) return;
+	if (!isRunLeaseHeldByWorker(run, options)) return;
 	return await updateRunIfCurrent(storage, namespace, store, run, extendedRunLeasePatch(run, options.now, options.leaseDuration));
 }
 async function releaseWorkflowRunLease(storage, namespace, store, options) {
 	const run = await store.getRun(options.runId);
-	if (!isWorkflowRunLeaseHeldByWorker(run, options)) return;
+	if (!isRunLeaseHeldByWorker(run, options)) return;
 	return await updateRunIfCurrent(storage, namespace, store, run, releaseRunLeasePatch(run, options.now));
 }
-function isSameReadableWorkflowRunRevision(latest, current, namespace) {
-	return latest !== void 0 && isReadableWorkflowRunRecord(latest, namespace) && isSameWorkflowStorageValue(omitUndefined(latest), omitUndefined(current));
+function isSameReadableRunRevision(latest, current, namespace) {
+	return latest !== void 0 && isReadableRunRecord(latest, namespace) && deepEquals(omitUndefined(latest), omitUndefined(current));
 }
-async function isStoredWorkflowRunRevisionCurrent(storage, namespace, currentRun) {
-	return isSameReadableWorkflowRunRevision(await getReadableStoredWorkflowRunValue(storage, namespace, currentRun.id), currentRun, namespace);
+async function isStoredRunRevisionCurrent(storage, namespace, currentRun) {
+	return isSameReadableRunRevision(await getWorkflowRun(storage, namespace, currentRun.id), currentRun, namespace);
 }
-async function getReadableStoredWorkflowRun(storage, namespace, runId) {
+async function getReadableStoredRun(storage, namespace, runId) {
 	const runValue = await storage.get(makeRunKey(namespace, runId));
-	const run = parseStoredWorkflowRunRecord(runValue);
-	return isReadableWorkflowRunRecord(run, namespace) ? run : void 0;
-}
-async function getReadableStoredWorkflowRunValue(storage, namespace, runId) {
-	const run = await storage.get(makeRunKey(namespace, runId));
-	return isReadableWorkflowRunRecord(run, namespace) ? run : void 0;
+	const run = parseStoredRunRecord(runValue);
+	return isReadableRunRecord(run, namespace) ? run : void 0;
 }
-async function requireReadableStoredWorkflowRun(storage, namespace, runId) {
-	const run = await getReadableStoredWorkflowRun(storage, namespace, runId);
+async function requireReadableStoredRun(storage, namespace, runId) {
+	const run = await getReadableStoredRun(storage, namespace, runId);
 	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
 	return run;
 }
 function shouldRollbackAppendedEventForRun(namespace, run, event) {
-	if (run === void 0 || !isReadableWorkflowRunRecord(run, namespace)) return true;
-	return isTerminalWorkflowRunStatus(run.status) && !isTerminalWorkflowLifecycleEventForRun(run, event);
+	if (run === void 0 || !isReadableRunRecord(run, namespace)) return true;
+	return isTerminalRunStatus(run.status) && !isTerminalEventForRun(run, event);
 }
-function isWorkflowRunStaleForAppend(currentRun, event) {
-	return isTerminalWorkflowRunStatus(currentRun.status) && !isTerminalWorkflowLifecycleEventForRun(currentRun, event);
+function isRunStaleForAppend(currentRun, event) {
+	return isTerminalRunStatus(currentRun.status) && !isTerminalEventForRun(currentRun, event);
 }
 async function rollbackAppendedEventIfRunStale(storage, namespace, runId, event, events) {
-	if (!shouldRollbackAppendedEventForRun(namespace, await getReadableStoredWorkflowRunValue(storage, namespace, runId), event)) return false;
+	if (!shouldRollbackAppendedEventForRun(namespace, await getWorkflowRun(storage, namespace, runId), event)) return false;
 	await rollbackAppendedEventIfCurrent(storage, namespace, runId, events);
 	return true;
 }
 function claimedRunPatch(run, workerId, now, leaseDuration) {
-	const timestamp = now;
 	const lastTransitionReason = isStaleLeaseClaim(run, now) ? "reclaimed" : "claimed";
 	return {
 		...run,
 		status: "running",
 		attempts: nextRunAttempt(run.attempts),
-		idempotencyKey: run.idempotencyKey,
-		parentRunId: run.parentRunId,
-		parentStepId: run.parentStepId,
-		parentStepName: run.parentStepName,
-		parentStepAttempt: run.parentStepAttempt,
 		workerId,
-		createdAt: run.createdAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
+		updatedAt: now,
+		lastTransitionAt: now,
 		lastTransitionReason,
-		startedAt: run.startedAt ?? timestamp,
+		startedAt: run.startedAt ?? now,
 		leaseExpiresAt: now.add(leaseDuration),
-		deadlineAt: run.deadlineAt,
 		availableAt: void 0,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
+		...CLEARED_RETRY,
+		...UNFINISHED
 	};
 }
 function extendedRunLeasePatch(run, now, leaseDuration) {
-	const timestamp = now;
 	return {
 		...run,
-		idempotencyKey: run.idempotencyKey,
-		parentRunId: run.parentRunId,
-		parentStepId: run.parentStepId,
-		parentStepName: run.parentStepName,
-		parentStepAttempt: run.parentStepAttempt,
-		createdAt: run.createdAt,
-		updatedAt: timestamp,
-		lastTransitionAt: run.lastTransitionAt ?? timestamp,
-		deadlineAt: run.deadlineAt,
-		startedAt: run.startedAt ?? timestamp,
+		updatedAt: now,
+		lastTransitionAt: run.lastTransitionAt ?? now,
+		startedAt: run.startedAt ?? now,
 		leaseExpiresAt: now.add(leaseDuration),
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0
+		...CLEARED_RETRY,
+		...UNFINISHED
 	};
 }
 function releaseRunLeasePatch(run, now) {
-	const timestamp = now;
 	return {
 		...run,
 		status: "waiting",
-		idempotencyKey: run.idempotencyKey,
-		parentRunId: run.parentRunId,
-		parentStepId: run.parentStepId,
-		parentStepName: run.parentStepName,
-		parentStepAttempt: run.parentStepAttempt,
-		availableAt: timestamp,
-		createdAt: run.createdAt,
-		updatedAt: timestamp,
-		lastTransitionAt: timestamp,
+		availableAt: now,
+		updatedAt: now,
+		lastTransitionAt: now,
 		lastTransitionReason: "waiting",
-		deadlineAt: run.deadlineAt,
-		startedAt: run.startedAt ?? timestamp,
-		retryAt: void 0,
-		retryReason: void 0,
-		retryAttempt: void 0,
-		retryStepId: void 0,
-		retryStepName: void 0,
-		error: void 0,
-		output: void 0,
-		finishedAt: void 0,
-		workerId: void 0,
-		leaseExpiresAt: void 0
+		startedAt: run.startedAt ?? now,
+		...CLEARED_RETRY,
+		...UNFINISHED,
+		...CLEARED_LEASE
 	};
 }
 async function firstClaimableRun(store, options, listOptions) {
 	return (await store.listRuns(listOptions)).find((run) => canClaimRun(run, options, listOptions));
 }
-function claimableWorkflowRunListOptions(options) {
+function claimableRunListOptions(options) {
 	return {
 		...options,
 		workerId: void 0,
@@ -216,18 +175,18 @@ function claimableWorkflowRunListOptions(options) {
 	};
 }
 function canClaimRun(run, options, listOptions) {
-	if (!matchesClaimableWorkflowRunListOptions(run, listOptions)) return false;
+	if (!matchesClaimableRunListOptions(run, listOptions)) return false;
 	if (run.status === "pending" || run.status === "waiting") return run.availableAt === void 0 || Temporal.Instant.compare(run.availableAt, options.now) <= 0;
 	if (run.status !== "running") return false;
 	if (run.workerId === void 0) return true;
 	if (run.leaseExpiresAt === void 0) return true;
 	return Temporal.Instant.compare(run.leaseExpiresAt, options.now) <= 0;
 }
-function isWorkflowRunLeaseHeldByWorker(run, options) {
+function isRunLeaseHeldByWorker(run, options) {
 	return run !== void 0 && run.status === "running" && run.workerId === options.workerId && (options.attempts === void 0 || run.attempts === options.attempts) && run.leaseExpiresAt !== void 0 && Temporal.Instant.compare(run.leaseExpiresAt, options.now) > 0;
 }
-function matchesClaimableWorkflowRunListOptions(run, listOptions) {
-	return matchesWorkflowRunListOptions(run, listOptions) && (listOptions.retryReason !== void 0 || run.retryReason === void 0);
+function matchesClaimableRunListOptions(run, listOptions) {
+	return matchesRunListOptions(run, listOptions) && (listOptions.retryReason !== void 0 || run.retryReason === void 0);
 }
 function isStaleLeaseClaim(run, now) {
 	if (run.status !== "running") return false;
@@ -236,4 +195,4 @@ function isStaleLeaseClaim(run, now) {
 	return Temporal.Instant.compare(run.leaseExpiresAt, now) <= 0;
 }
 //#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 { claimWorkflowRun, countWorkflowRuns, extendWorkflowRunLease, getReadableStoredRun, getWorkflowRun, isRunStaleForAppend, isStoredRunRevisionCurrent, listWorkflowRuns, listWorkflowRunsPage, releaseWorkflowRunLease, requireReadableStoredRun, rollbackAppendedEventIfRunStale, updateRunIfCurrent, updateWorkflowRun };

package/dist/store/schedule.d.mts

@@ -1,12 +1,10 @@
 import { WorkflowPage } from "../types/pagination.mjs";
 import { ListSchedulesOptions, ListSchedulesPageOptions, ScheduleId, ScheduleRecord } from "../types/schedule.mjs";
 import { WorkflowStorage } from "../types/store.mjs";
-import { StorageValue } from "@temelj/storage";
 //#region src/store/schedule.d.ts
-declare function createSchedule<TInput>(storage: WorkflowStorage, namespace: string, schedule: ScheduleRecord<TInput>): Promise<ScheduleRecord<TInput>>;
-declare function getReadableSchedule<TInput = StorageValue>(storage: WorkflowStorage, namespace: string, scheduleId: ScheduleId): Promise<ScheduleRecord<TInput> | undefined>;
-declare function updateScheduleIfCurrent<TInput>(storage: WorkflowStorage, namespace: string, current: ScheduleRecord, next: ScheduleRecord<TInput>): Promise<ScheduleRecord<TInput> | undefined>;
-declare function listSchedules(storage: WorkflowStorage, namespace: string, options?: ListSchedulesOptions): Promise<readonly ScheduleRecord[]>;
-declare function listSchedulesPage(storage: WorkflowStorage, namespace: string, options?: ListSchedulesPageOptions): Promise<WorkflowPage<ScheduleRecord>>;
-//#endregion
-export { createSchedule, getReadableSchedule, listSchedules, listSchedulesPage, updateScheduleIfCurrent };
+export declare function createSchedule(storage: WorkflowStorage, namespace: string, schedule: ScheduleRecord): Promise<ScheduleRecord>;
+export declare function getReadableSchedule(storage: WorkflowStorage, namespace: string, scheduleId: ScheduleId): Promise<ScheduleRecord | undefined>;
+export declare function updateScheduleIfCurrent(storage: WorkflowStorage, namespace: string, current: ScheduleRecord, next: ScheduleRecord): Promise<ScheduleRecord | undefined>;
+export declare function listSchedules(storage: WorkflowStorage, namespace: string, options?: ListSchedulesOptions): Promise<readonly ScheduleRecord[]>;
+export declare function listSchedulesPage(storage: WorkflowStorage, namespace: string, options?: ListSchedulesPageOptions): Promise<WorkflowPage<ScheduleRecord>>;
+//#endregion

package/dist/store/schedule.mjs

@@ -1,18 +1,18 @@
-import { limitWorkflowItems } from "../utility.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowScheduleAlreadyExistsError, WorkflowScheduleError } from "../errors/schedule.mjs";
 import "../errors/mod.mjs";
+import { limitItems, omitUndefined } from "../collection.mjs";
 import { makeScheduleKey } from "../store-keys.mjs";
+import { makeScheduleCursorKey, pageItems } from "../pagination.mjs";
 import { toStorageValue } from "./storage-value.mjs";
 import { isReadableScheduleRecord } from "./validation.mjs";
-import { makeScheduleCursorKey, pageItems } from "../pagination.mjs";
-import { compactWorkflowStoreRecord } from "./compaction.mjs";
 import { querySchedules } from "./query.mjs";
 //#region src/store/schedule.ts
 async function createSchedule(storage, namespace, schedule) {
 	if (schedule.namespace !== namespace) WorkflowScheduleError.namespaceMismatch(schedule.namespace, namespace);
-	if (!isReadableScheduleRecord(schedule, namespace)) WorkflowScheduleError.recordInvalid();
-	const compact = compactWorkflowStoreRecord(schedule);
-	if (!await storage.compareAndSet(makeScheduleKey(namespace, schedule.id), void 0, toStorageValue(compact))) WorkflowScheduleAlreadyExistsError.alreadyExists(schedule.id);
+	if (!isReadableScheduleRecord(schedule, namespace)) throw new WorkflowScheduleError("Workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_RECORD_INVALID, void 0);
+	const compact = omitUndefined(schedule);
+	if (!await storage.compareAndSet(makeScheduleKey(namespace, schedule.id), void 0, toStorageValue(compact))) throw new WorkflowScheduleAlreadyExistsError(schedule.id);
 	return compact;
 }
 async function getReadableSchedule(storage, namespace, scheduleId) {
@@ -22,15 +22,15 @@ async function getReadableSchedule(storage, namespace, scheduleId) {
 async function updateScheduleIfCurrent(storage, namespace, current, next) {
 	if (current.namespace !== namespace) WorkflowScheduleError.namespaceMismatch(current.namespace, namespace);
 	if (next.namespace !== namespace) WorkflowScheduleError.namespaceMismatch(next.namespace, namespace);
-	if (current.id !== next.id) WorkflowScheduleError.idChangeRejected();
-	if (!isReadableScheduleRecord(current, namespace)) WorkflowScheduleError.currentRecordInvalid();
-	if (!isReadableScheduleRecord(next, namespace)) WorkflowScheduleError.nextRecordInvalid();
-	const compact = compactWorkflowStoreRecord(next);
+	if (current.id !== next.id) throw new WorkflowScheduleError("Workflow schedule id cannot change", WorkflowErrorCode.SCHEDULE_ID_CHANGE_REJECTED, void 0);
+	if (!isReadableScheduleRecord(current, namespace)) throw new WorkflowScheduleError("Current workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_CURRENT_RECORD_INVALID, void 0);
+	if (!isReadableScheduleRecord(next, namespace)) throw new WorkflowScheduleError("Next workflow schedule record is invalid", WorkflowErrorCode.SCHEDULE_NEXT_RECORD_INVALID, void 0);
+	const compact = omitUndefined(next);
 	return await storage.compareAndSet(makeScheduleKey(namespace, current.id), toStorageValue(current), toStorageValue(compact)) ? compact : void 0;
 }
 async function listSchedules(storage, namespace, options) {
 	const schedules = await querySchedules(storage, namespace, options, { label: "Workflow schedule list options" });
-	return limitWorkflowItems(schedules, options?.limit);
+	return limitItems(schedules, options?.limit);
 }
 async function listSchedulesPage(storage, namespace, options) {
 	const schedules = await querySchedules(storage, namespace, {

package/dist/store/step-attempt.d.mts

@@ -1,14 +1,11 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.mjs";
 import { WorkflowPage } from "../types/pagination.mjs";
-import { WorkflowListStepAttemptsPageOptions } from "../types/run-list.mjs";
-import { WorkflowListStepAttemptsOptions, WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
-import "../types/run.mjs";
-import { WorkflowEventReader, WorkflowRunReaderRepository, WorkflowStorage } from "../types/store.mjs";
+import { ListStepAttemptsPageOptions } from "../types/run-list.mjs";
+import { ListStepAttemptsOptions, StepAttemptRecord } from "../types/step-attempts.mjs";
+import { WorkflowStorage, WorkflowStore } from "../types/store.mjs";
 //#region src/store/step-attempt.d.ts
-type WorkflowStepAttemptReadStore = WorkflowRunReaderRepository & WorkflowEventReader;
-declare function listWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStepAttemptReadStore, runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<readonly WorkflowStepAttemptRecord[]>;
-declare function listWorkflowStepAttemptsPage(storage: WorkflowStorage, namespace: string, store: WorkflowStepAttemptReadStore, runId: RunId, options?: WorkflowListStepAttemptsPageOptions): Promise<WorkflowPage<WorkflowStepAttemptRecord>>;
-declare function countWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStepAttemptReadStore, runId: RunId, options?: WorkflowListStepAttemptsOptions): Promise<number>;
-declare function repairWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStepAttemptReadStore, runId: RunId): Promise<readonly WorkflowStepAttemptRecord[]>;
-//#endregion
-export { countWorkflowStepAttempts, listWorkflowStepAttempts, listWorkflowStepAttemptsPage, repairWorkflowStepAttempts };
+export declare function listWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStore, runId: RunId, options?: ListStepAttemptsOptions): Promise<readonly StepAttemptRecord[]>;
+export declare function listWorkflowStepAttemptsPage(storage: WorkflowStorage, namespace: string, store: WorkflowStore, runId: RunId, options?: ListStepAttemptsPageOptions): Promise<WorkflowPage<StepAttemptRecord>>;
+export declare function countWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStore, runId: RunId, options?: ListStepAttemptsOptions): Promise<number>;
+export declare function repairWorkflowStepAttempts(storage: WorkflowStorage, namespace: string, store: WorkflowStore, runId: RunId): Promise<readonly StepAttemptRecord[]>;
+//#endregion

package/dist/store/step-attempt.mjs

@@ -1,24 +1,24 @@
-import { limitWorkflowItems } from "../utility.mjs";
-import { makeWorkflowStepAttemptCursorKey, pageItems } from "../pagination.mjs";
+import { limitItems } from "../collection.mjs";
+import { makeStepAttemptCursorKey, pageItems } from "../pagination.mjs";
 import { reconcileStepAttempts } from "./materialization.mjs";
-import { getRequiredStoreRun, queryWorkflowStepAttempts } from "./query.mjs";
+import { getRequiredRun, queryStepAttempts } from "./query.mjs";
 //#region src/store/step-attempt.ts
 async function listWorkflowStepAttempts(storage, namespace, store, runId, options) {
-	const attempts = await queryWorkflowStepAttempts(storage, namespace, store, runId, options, { label: "Workflow step attempt list options" });
-	return limitWorkflowItems(attempts, options?.limit);
+	const attempts = await queryStepAttempts(storage, namespace, store, runId, options, { label: "Workflow step attempt list options" });
+	return limitItems(attempts, options?.limit);
 }
 async function listWorkflowStepAttemptsPage(storage, namespace, store, runId, options) {
-	const attempts = await queryWorkflowStepAttempts(storage, namespace, store, runId, {
+	const attempts = await queryStepAttempts(storage, namespace, store, runId, {
 		...options,
 		limit: void 0
 	}, { label: "Workflow step attempt page options" });
-	return pageItems(attempts, options, "Workflow step attempt page", makeWorkflowStepAttemptCursorKey);
+	return pageItems(attempts, options, "Workflow step attempt page", makeStepAttemptCursorKey);
 }
 async function countWorkflowStepAttempts(storage, namespace, store, runId, options) {
-	return (await queryWorkflowStepAttempts(storage, namespace, store, runId, options, { label: "Workflow step attempt list options" })).length;
+	return (await queryStepAttempts(storage, namespace, store, runId, options, { label: "Workflow step attempt list options" })).length;
 }
 async function repairWorkflowStepAttempts(storage, namespace, store, runId) {
-	await getRequiredStoreRun(store, runId);
+	await getRequiredRun(store, runId);
 	return await reconcileStepAttempts(storage, namespace, runId, await store.getEvents(runId));
 }
 //#endregion

package/dist/store/storage-value.d.mts

@@ -1,5 +1,5 @@
 import { StorageValue } from "@temelj/storage";
 //#region src/store/storage-value.d.ts
-declare function toStorageValue(value: unknown): StorageValue;
-//#endregion
-export { toStorageValue };
+/** Validates storage writes and omits undefined optional fields from workflow records. */
+export declare function toStorageValue(value: unknown): StorageValue;
+//#endregion

package/dist/store/storage-value.mjs

@@ -1,6 +1,22 @@
+import { parse } from "../schema/common.mjs";
+import { persistedValueSchema } from "../schema/persisted-value.mjs";
+import { isPlainObject } from "@temelj/value";
 //#region src/store/storage-value.ts
+/** Validates storage writes and omits undefined optional fields from workflow records. */
 function toStorageValue(value) {
-	return value;
+	return normalizeStoredValue(value, /* @__PURE__ */ new WeakSet());
+}
+function normalizeStoredValue(value, active) {
+	if (!Array.isArray(value) && !isPlainObject(value)) return parse(persistedValueSchema, value);
+	if (active.has(value)) throw new TypeError("Circular workflow records cannot be stored");
+	active.add(value);
+	try {
+		if (Array.isArray(value)) return Array.from(value, (item) => normalizeStoredValue(item, active));
+		if (Object.getOwnPropertySymbols(value).some((key) => Object.prototype.propertyIsEnumerable.call(value, key))) throw new TypeError("Symbol keys cannot be stored in workflow records");
+		return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, normalizeStoredValue(item, active)]));
+	} finally {
+		active.delete(value);
+	}
 }
 //#endregion
 export { toStorageValue };

package/dist/store/validation.d.mts

@@ -1,35 +1,32 @@
 import { CleanupMarkerRecord } from "../types/cleanup.mjs";
 import { ScheduleRecord } from "../types/schedule.mjs";
 import { LockRecord } from "../types/lock.mjs";
-import { WorkflowStepAttemptRecord } from "../types/step-attempts.mjs";
-import { WorkflowRunRecord, WorkflowRunTransitionReason } from "../types/run.mjs";
+import { StepAttemptRecord } from "../types/step-attempts.mjs";
+import { RunRecord, RunTransitionReason } from "../types/run.mjs";
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowMessageIdempotencyIndex } from "../types/store.mjs";
+import { MessageIdempotencyIndex } from "../types/store.mjs";
 import { StorageValue } from "@temelj/storage";
 //#region src/store/validation.d.ts
 /** Returns whether an unknown value is a readable run record in the expected namespace. */
-declare function isReadableWorkflowRunRecord(run: unknown, expectedNamespace: string): run is WorkflowRunRecord;
+export declare function isReadableRunRecord(run: unknown, expectedNamespace: string): run is RunRecord;
 /** Returns whether an unknown value is a run record that can participate in indexed list queries. */
-declare function isListableWorkflowRunRecord(run: unknown, expectedNamespace: string): run is WorkflowRunRecord & {
-  readonly lastTransitionReason: WorkflowRunTransitionReason;
+export declare function isListableRunRecord(run: unknown, expectedNamespace: string): run is RunRecord & {
+  readonly lastTransitionReason: RunTransitionReason;
 };
 /** Parses a stored workflow run record, if one exists. */
-declare function parseStoredWorkflowRunRecord(value: StorageValue | undefined): WorkflowRunRecord | undefined;
+export declare function parseStoredRunRecord(value: StorageValue | undefined): RunRecord | undefined;
 /** Returns whether an unknown value is a readable schedule record in the expected namespace. */
-declare function isReadableScheduleRecord<TInput = StorageValue>(schedule: unknown, expectedNamespace: string): schedule is ScheduleRecord<TInput>;
+export declare function isReadableScheduleRecord(schedule: unknown, expectedNamespace: string): schedule is ScheduleRecord;
 /** Returns whether an unknown value is a readable lock record in the expected namespace. */
-declare function isReadableLockRecord(lock: unknown, expectedNamespace: string): lock is LockRecord;
-/** Returns whether an unknown value is a readable durable workflow event record. */
-declare function isReadableEventRecord(event: unknown): event is EventRecord;
+export declare function isReadableLockRecord(lock: unknown, expectedNamespace: string): lock is LockRecord;
+export declare function isReadableEventRecord(event: unknown): event is EventRecord;
 /** Parses a readable cleanup marker record, if the value has the expected shape. */
-declare function readableCleanupMarkerRecord(marker: unknown): CleanupMarkerRecord | undefined;
+export declare function readableCleanupMarkerRecord(marker: StorageValue | undefined): CleanupMarkerRecord | undefined;
 /** Parses a stored materialized step-attempt record, if one exists. */
-declare function parseStoredWorkflowStepAttemptRecord(value: StorageValue | undefined): WorkflowStepAttemptRecord | undefined;
-/** Returns whether an unknown value is a readable message idempotency index record. */
-declare function isReadableMessageIdempotencyIndex(value: unknown): value is WorkflowMessageIdempotencyIndex;
+export declare function parseStoredStepAttemptRecord(value: StorageValue | undefined): StepAttemptRecord | undefined;
+export declare function isReadableMessageIdempotencyIndex(value: unknown): value is MessageIdempotencyIndex;
 /** Returns whether the stored message idempotency index matches the expected logical index. */
-declare function isSameMessageIdempotencyIndex(current: unknown, value: WorkflowMessageIdempotencyIndex): boolean;
-declare function requireReadableStoreRun(run: WorkflowRunRecord, namespace: string): void;
-declare function requireValidRunTransition(current: WorkflowRunRecord, next: WorkflowRunRecord): void;
-//#endregion
-export { isListableWorkflowRunRecord, isReadableEventRecord, isReadableLockRecord, isReadableMessageIdempotencyIndex, isReadableScheduleRecord, isReadableWorkflowRunRecord, isSameMessageIdempotencyIndex, parseStoredWorkflowRunRecord, parseStoredWorkflowStepAttemptRecord, readableCleanupMarkerRecord, requireReadableStoreRun, requireValidRunTransition };
+export declare function isSameMessageIdempotencyIndex(current: StorageValue | MessageIdempotencyIndex | undefined, value: MessageIdempotencyIndex): boolean;
+export declare function requireReadableStoreRun(run: RunRecord, namespace: string): void;
+export declare function requireValidRunTransition(current: RunRecord, next: RunRecord): void;
+//#endregion

package/dist/store/validation.mjs

@@ -1,69 +1,66 @@
+import { parse } from "../schema/common.mjs";
 import { WorkflowRunNotFoundError, WorkflowRunTransitionError } from "../errors/run.mjs";
-import { workflowRunRecordSchema } from "../types/run.mjs";
 import "../errors/mod.mjs";
-import { workflowEventRecordSchema } from "../types/events.mjs";
-import { workflowCleanupMarkerRecordSchema } from "../types/cleanup.mjs";
-import { workflowLockRecordSchema } from "../types/lock.mjs";
-import { workflowScheduleRecordSchema } from "../types/schedule.mjs";
-import { workflowStepAttemptRecordSchema } from "../types/step-attempts.mjs";
-import { workflowMessageIdempotencyIndexSchema } from "./schema.mjs";
+import { runRecordSchema } from "../schema/run.mjs";
+import { eventRecordSchema } from "../schema/events.mjs";
+import { cleanupMarkerRecordSchema, lockRecordSchema, messageIdempotencyIndexSchema, scheduleRecordSchema, stepAttemptRecordSchema } from "../schema/store.mjs";
+import { ss } from "@temelj/standard-schema";
 //#region src/store/validation.ts
 /** Returns whether an unknown value is a readable run record in the expected namespace. */
-function isReadableWorkflowRunRecord(run, expectedNamespace) {
-	const parsed = workflowRunRecordSchema.safeParse(run);
-	return parsed.success && parsed.data.namespace === expectedNamespace;
+function isReadableRunRecord(run, expectedNamespace) {
+	const parsed = ss.safeParseSync(runRecordSchema, run);
+	return parsed.success && parsed.value.namespace === expectedNamespace;
 }
 /** Returns whether an unknown value is a run record that can participate in indexed list queries. */
-function isListableWorkflowRunRecord(run, expectedNamespace) {
-	return isReadableWorkflowRunRecord(run, expectedNamespace);
+function isListableRunRecord(run, expectedNamespace) {
+	return isReadableRunRecord(run, expectedNamespace);
 }
 /** Parses a stored workflow run record, if one exists. */
-function parseStoredWorkflowRunRecord(value) {
-	return value === void 0 ? void 0 : workflowRunRecordSchema.parse(value);
+function parseStoredRunRecord(value) {
+	return value === void 0 ? void 0 : parse(runRecordSchema, value);
 }
 /** Returns whether an unknown value is a readable schedule record in the expected namespace. */
 function isReadableScheduleRecord(schedule, expectedNamespace) {
-	const parsed = workflowScheduleRecordSchema.safeParse(schedule);
-	return parsed.success && parsed.data.namespace === expectedNamespace;
+	const parsed = ss.safeParseSync(scheduleRecordSchema, schedule);
+	return parsed.success && parsed.value.namespace === expectedNamespace;
 }
 /** Returns whether an unknown value is a readable lock record in the expected namespace. */
 function isReadableLockRecord(lock, expectedNamespace) {
-	const parsed = workflowLockRecordSchema.safeParse(lock);
-	return parsed.success && parsed.data.namespace === expectedNamespace;
+	const parsed = ss.safeParseSync(lockRecordSchema, lock);
+	return parsed.success && parsed.value.namespace === expectedNamespace;
 }
-/** Returns whether an unknown value is a readable durable workflow event record. */
 function isReadableEventRecord(event) {
-	return workflowEventRecordSchema.safeParse(event).success;
+	return ss.safeParseSync(eventRecordSchema, event).success;
 }
 /** Parses a readable cleanup marker record, if the value has the expected shape. */
 function readableCleanupMarkerRecord(marker) {
-	const parsed = workflowCleanupMarkerRecordSchema.safeParse(marker);
-	return parsed.success ? parsed.data : void 0;
+	const parsed = ss.safeParseSync(cleanupMarkerRecordSchema, marker);
+	return parsed.success ? parsed.value : void 0;
 }
 /** Parses a stored materialized step-attempt record, if one exists. */
-function parseStoredWorkflowStepAttemptRecord(value) {
-	return value === void 0 ? void 0 : workflowStepAttemptRecordSchema.parse(value);
+function parseStoredStepAttemptRecord(value) {
+	return value === void 0 ? void 0 : parse(stepAttemptRecordSchema, value);
 }
-/** Returns whether an unknown value is a readable message idempotency index record. */
 function isReadableMessageIdempotencyIndex(value) {
-	return workflowMessageIdempotencyIndexSchema.safeParse(value).success;
+	return ss.safeParseSync(messageIdempotencyIndexSchema, value).success;
 }
 /** Returns whether the stored message idempotency index matches the expected logical index. */
 function isSameMessageIdempotencyIndex(current, value) {
-	const parsedCurrent = workflowMessageIdempotencyIndexSchema.safeParse(current);
-	return parsedCurrent.success && parsedCurrent.data.runId === value.runId && parsedCurrent.data.messageId === value.messageId && Temporal.Instant.compare(parsedCurrent.data.timestamp, value.timestamp) === 0;
+	const parsedCurrent = ss.safeParseSync(messageIdempotencyIndexSchema, current);
+	return parsedCurrent.success && parsedCurrent.value.runId === value.runId && parsedCurrent.value.messageId === value.messageId && Temporal.Instant.compare(parsedCurrent.value.timestamp, value.timestamp) === 0;
 }
 function requireReadableStoreRun(run, namespace) {
 	const runId = run.id;
-	if (!isReadableWorkflowRunRecord(run, namespace)) WorkflowRunNotFoundError.notFound(runId);
+	const parsed = ss.safeParseSync(runRecordSchema, run);
+	if (!parsed.success || parsed.value.namespace !== namespace) WorkflowRunNotFoundError.notFound(runId);
 }
 function requireValidRunTransition(current, next) {
 	if (current.status === next.status) return;
-	if (canTransitionWorkflowRunStatus(current.status, next.status)) return;
-	WorkflowRunTransitionError.invalidTransition(current.id, current.status, next.status);
+	if (canTransitionRunStatus(current.status, next.status)) return;
+	throw new WorkflowRunTransitionError(current.id, current.status, next.status);
 }
 /** Returns whether a run status transition is allowed by the workflow state machine. */
-function canTransitionWorkflowRunStatus(from, to) {
+function canTransitionRunStatus(from, to) {
 	switch (from) {
 		case "pending": return to === "running" || to === "waiting" || to === "failed" || to === "canceled";
 		case "running": return to === "waiting" || to === "completed" || to === "failed" || to === "canceled";
@@ -74,4 +71,4 @@ function canTransitionWorkflowRunStatus(from, to) {
 	}
 }
 //#endregion
-export { isListableWorkflowRunRecord, isReadableEventRecord, isReadableLockRecord, isReadableMessageIdempotencyIndex, isReadableScheduleRecord, isReadableWorkflowRunRecord, isSameMessageIdempotencyIndex, parseStoredWorkflowRunRecord, parseStoredWorkflowStepAttemptRecord, readableCleanupMarkerRecord, requireReadableStoreRun, requireValidRunTransition };
+export { isListableRunRecord, isReadableEventRecord, isReadableLockRecord, isReadableMessageIdempotencyIndex, isReadableRunRecord, isReadableScheduleRecord, isSameMessageIdempotencyIndex, parseStoredRunRecord, parseStoredStepAttemptRecord, readableCleanupMarkerRecord, requireReadableStoreRun, requireValidRunTransition };