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

package/dist/engine/run-service.mjs

@@ -1,134 +1,166 @@
+import { normalizeAttributePatch } from "../attributes.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowStateError } from "../errors/base.mjs";
 import { WorkflowPermanentFailureError } from "../errors/failures.mjs";
-import { getRequiredRun, isScheduledWorkflowRunStatus, nextRunAttempt } from "../utility.mjs";
-import { normalizeWorkflowAttributePatch } from "../attributes.mjs";
 import "../errors/mod.mjs";
-import { defineWorkflowFromName } from "../definition.mjs";
-import "./retry-policy.mjs";
+import { defineFromName } from "../definition.mjs";
+import { isScheduledRunStatus, nextRunAttempt } from "../run-status.mjs";
+import { getRequiredRun } from "../store/query.mjs";
 import { serializeError, toPersistedValue } from "./serialization.mjs";
-import { cancelRunWithChildren, releaseLocksForRun, setRunAttributesIfCurrent, transitionRunAfterStaleLeaseRelease, transitionRunToManualRetry, transitionRunToPermanentFailure, transitionRunToRescheduled, updateRunMetadataIfCurrent } from "./state.mjs";
+import { cancelRunWithChildren, releaseLocksForRun, setRunAttributesIfCurrent, transitionRunAfterStaleLeaseRelease, transitionRunToFailed, transitionRunToManualRetry, transitionRunToRescheduled, updateRunMetadataIfCurrent } from "./state.mjs";
+import { retentionCleanupOptions } from "./run-utils.mjs";
 //#region src/engine/run-service.ts
-async function rerunWorkflowRun(service, startWorkflow, runId, rerunOptions) {
-	const sourceRun = await getRequiredRun(service.store, runId);
-	const options = rerunOptions;
-	const definition = await resolveRerunWorkflowDefinition(sourceRun, options);
-	const start = options?.start;
+async function rerunRun(context, startWorkflow, runId, rerunOptions) {
+	const sourceRun = await getRequiredRun(context.store, runId);
+	const definition = await resolveRerunDefinition(sourceRun, rerunOptions);
+	const start = rerunOptions?.start;
+	const contextOptions = { context: sourceRun.context };
 	return await startWorkflow(definition, sourceRun.input, {
-		...sourceRun.context === void 0 ? {} : { context: sourceRun.context },
+		...contextOptions,
 		...start
 	});
 }
-async function resolveRerunWorkflowDefinition(sourceRun, options) {
+async function resolveRerunDefinition(sourceRun, options) {
 	const workflowName = options?.workflowName ?? sourceRun.workflowName;
-	const resolvedWorkflowVersion = await resolveWorkflowVersion(workflowName, options !== void 0 && "workflowVersion" in options ? options.workflowVersion : sourceRun.workflowVersion, options?.workflowVersionResolver);
-	return defineWorkflowFromName(workflowName, resolvedWorkflowVersion);
+	const resolvedWorkflowVersion = await resolveVersion(workflowName, options !== void 0 && "workflowVersion" in options ? options.workflowVersion : sourceRun.workflowVersion, options?.workflowVersionResolver);
+	return defineFromName(workflowName, resolvedWorkflowVersion);
 }
-async function rescheduleWorkflowRun(service, lifecycle, runId, rescheduleOptions) {
-	const options = rescheduleOptions;
-	const now = service.now();
-	const availableAt = options?.availableAt ?? now;
+/** Applies an operator change to a run, retrying when another writer updates the run first. */
+async function applyRunOperation(context, lifecycle, runId, operation) {
 	for (let attempt = 0; attempt < 16; attempt++) {
-		const current = await getRequiredRun(service.store, runId);
-		if (!isScheduledWorkflowRunStatus(current.status)) WorkflowStateError.runCannotBeRescheduled(runId);
-		if (current.availableAt !== void 0 && Temporal.Instant.compare(current.availableAt, availableAt) === 0 && current.lastTransitionReason === "rescheduled") return current;
-		const updated = await service.store.updateRunIfCurrent(current, transitionRunToRescheduled(current, now, availableAt));
+		const current = await getRequiredRun(context.store, runId);
+		const next = operation.next(current);
+		if (next === void 0) return current;
+		const updated = await context.store.updateRunIfCurrent(current, next);
 		if (updated !== void 0) {
-			await releaseLocksForRun(service.store, updated.id, now);
+			await operation.afterUpdate?.(updated);
 			await lifecycle.emitLifecycleEvent(updated, current);
 			return updated;
 		}
 	}
-	WorkflowStateError.failedRunReschedule(runId);
+	throw new WorkflowStateError(operation.failureMessage, {
+		code: operation.failureCode,
+		details: { runId }
+	});
 }
-async function releaseStaleWorkflowRunLease(service, lifecycle, runId, releaseOptions) {
-	const options = releaseOptions;
-	const now = service.now();
-	const availableAt = options?.availableAt ?? now;
-	for (let attempt = 0; attempt < 16; attempt++) {
-		const current = await getRequiredRun(service.store, runId);
-		if (isScheduledWorkflowRunStatus(current.status)) return current;
-		if (current.status !== "running") WorkflowStateError.staleLeaseReleaseRequiresRunning(runId);
-		if (current.workerId !== void 0 && typeof current.workerId === "string" && current.workerId.trim() !== "" && current.leaseExpiresAt !== void 0 && Temporal.Instant.compare(current.leaseExpiresAt, now) > 0) WorkflowStateError.runLeaseStillActive(runId);
-		const updated = await service.store.updateRunIfCurrent(current, transitionRunAfterStaleLeaseRelease(current, now, availableAt));
-		if (updated !== void 0) {
-			await lifecycle.emitLifecycleEvent(updated, current);
-			return updated;
-		}
-	}
-	WorkflowStateError.failedStaleRunLeaseRelease(runId);
+function stateError(message, code, runId) {
+	return new WorkflowStateError(message, {
+		code,
+		details: { runId }
+	});
 }
-async function retryFailedWorkflowRun(service, lifecycle, runId, retryOptions) {
-	const options = retryOptions;
-	const now = service.now();
-	const availableAt = options?.availableAt ?? now;
-	for (let attempt = 0; attempt < 16; attempt++) {
-		const current = await getRequiredRun(service.store, runId);
-		if (isScheduledWorkflowRunStatus(current.status)) return current;
-		if (current.status !== "failed") WorkflowStateError.runRetryRequiresFailed(runId);
-		if (current.lastTransitionReason === "permanent_failure" && options?.force !== true) WorkflowStateError.runRetryRequiresForceAfterPermanentFailure(runId);
-		if (options?.force !== true && current.retryReason === void 0 && current.retryAt === void 0) WorkflowStateError.failedRunRetryRequiresForce(runId);
-		const retryAttempt = nextRunAttempt(current.retryAttempt);
-		const updated = await service.store.updateRunIfCurrent(current, transitionRunToManualRetry(current, now, availableAt, retryAttempt));
-		if (updated !== void 0) {
-			await lifecycle.emitLifecycleEvent(updated, current);
-			return updated;
-		}
-	}
-	WorkflowStateError.failedRunRetry(runId);
+async function rescheduleWorkflowRun(context, lifecycle, runId, rescheduleOptions) {
+	const now = context.now();
+	const availableAt = rescheduleOptions?.availableAt ?? now;
+	return await applyRunOperation(context, lifecycle, runId, {
+		next: (current) => {
+			if (!isScheduledRunStatus(current.status)) throw stateError(`Workflow run cannot be rescheduled unless pending or waiting: ${runId}`, WorkflowErrorCode.STATE_RUN_CANNOT_BE_RESCHEDULED, runId);
+			return current.availableAt !== void 0 && Temporal.Instant.compare(current.availableAt, availableAt) === 0 && current.lastTransitionReason === "rescheduled" ? void 0 : transitionRunToRescheduled(current, now, availableAt);
+		},
+		afterUpdate: async (updated) => {
+			await releaseLocksForRun(context.store, updated.id, now);
+		},
+		failureMessage: `Failed to reschedule workflow run ${runId}`,
+		failureCode: WorkflowErrorCode.STATE_RUN_RESCHEDULE_FAILED
+	});
+}
+async function releaseStaleWorkflowRunLease(context, lifecycle, runId, releaseOptions) {
+	const now = context.now();
+	const availableAt = releaseOptions?.availableAt ?? now;
+	return await applyRunOperation(context, lifecycle, runId, {
+		next: (current) => {
+			if (isScheduledRunStatus(current.status)) return;
+			if (current.status !== "running") throw stateError(`Workflow run stale lease cannot be released unless running: ${runId}`, WorkflowErrorCode.STATE_STALE_LEASE_RELEASE_REQUIRES_RUNNING, runId);
+			if (current.workerId !== void 0 && current.workerId.trim() !== "" && current.leaseExpiresAt !== void 0 && Temporal.Instant.compare(current.leaseExpiresAt, now) > 0) throw stateError(`Workflow run lease is still active: ${runId}`, WorkflowErrorCode.STATE_RUN_LEASE_STILL_ACTIVE, runId);
+			return transitionRunAfterStaleLeaseRelease(current, now, availableAt);
+		},
+		failureMessage: `Failed to release stale workflow run lease ${runId}`,
+		failureCode: WorkflowErrorCode.STATE_STALE_RUN_LEASE_RELEASE_FAILED
+	});
 }
-async function markWorkflowRunPermanentlyFailed(service, lifecycle, runId, permanentFailureOptions) {
-	const now = service.now();
+async function retryFailedWorkflowRun(context, lifecycle, runId, retryOptions) {
+	const now = context.now();
+	const availableAt = retryOptions?.availableAt ?? now;
+	const force = retryOptions?.force === true;
+	return await applyRunOperation(context, lifecycle, runId, {
+		next: (current) => {
+			if (isScheduledRunStatus(current.status)) return;
+			if (current.status !== "failed") throw stateError(`Workflow run cannot be retried unless failed: ${runId}`, WorkflowErrorCode.STATE_RUN_RETRY_REQUIRES_FAILED, runId);
+			if (current.lastTransitionReason === "permanent_failure" && !force) throw stateError(`Workflow run cannot be retried after permanent failure without force: ${runId}`, WorkflowErrorCode.STATE_RUN_RETRY_REQUIRES_FORCE_AFTER_PERMANENT_FAILURE, runId);
+			if (!force && current.retryReason === void 0 && current.retryAt === void 0) throw stateError(`Workflow failed run retry requires force when no retry metadata exists: ${runId}`, WorkflowErrorCode.STATE_FAILED_RUN_RETRY_REQUIRES_FORCE, runId);
+			return transitionRunToManualRetry(current, now, availableAt, nextRunAttempt(current.retryAttempt));
+		},
+		failureMessage: `Failed to retry workflow run ${runId}`,
+		failureCode: WorkflowErrorCode.STATE_RUN_RETRY_FAILED
+	});
+}
+async function markWorkflowRunPermanentlyFailed(context, lifecycle, runId, permanentFailureOptions) {
+	const now = context.now();
 	const reason = permanentFailureOptions.reason;
-	for (let attempt = 0; attempt < 16; attempt++) {
-		const current = await getRequiredRun(service.store, runId);
-		if (current.status === "completed" || current.status === "canceled") WorkflowStateError.permanentFailureInvalidStatus(runId, current.status);
-		if (current.status === "failed" && current.lastTransitionReason === "permanent_failure" && current.error?.details?.reason === reason) return current;
-		const updated = await service.store.updateRunIfCurrent(current, transitionRunToPermanentFailure(current, serializeError(WorkflowPermanentFailureError.create({
-			runId,
-			reason
-		})), now));
-		if (updated !== void 0) {
-			await lifecycle.emitLifecycleEvent(updated, current);
-			return updated;
-		}
-	}
-	WorkflowStateError.failedPermanentRunFailure(runId);
+	return await applyRunOperation(context, lifecycle, runId, {
+		next: (current) => {
+			if (current.status === "completed" || current.status === "canceled") throw new WorkflowStateError(`Workflow run cannot be marked permanently failed from ${current.status}: ${runId}`, {
+				code: WorkflowErrorCode.STATE_PERMANENT_FAILURE_STATUS_INVALID,
+				details: {
+					runId,
+					status: current.status
+				}
+			});
+			if (current.status === "failed" && current.lastTransitionReason === "permanent_failure" && current.error?.details?.reason === reason) return;
+			return transitionRunToFailed(current, serializeError(new WorkflowPermanentFailureError({
+				runId,
+				reason
+			})), now, "permanent_failure");
+		},
+		failureMessage: `Failed to mark workflow run permanently failed ${runId}`,
+		failureCode: WorkflowErrorCode.STATE_PERMANENT_RUN_FAILURE_FAILED
+	});
 }
-async function updateWorkflowRunMetadata(service, lifecycle, runId, metadata) {
-	const persistedMetadata = toPersistedValue(metadata, "workflow run metadata", service.limits);
-	const timestamp = service.now();
-	const previousRun = await getRequiredRun(service.store, runId);
-	const updatedRun = await updateRunMetadataIfCurrent(service.store, runId, persistedMetadata, timestamp);
+async function updateWorkflowRunMetadata(context, lifecycle, runId, metadata) {
+	const persistedMetadata = toPersistedValue(metadata, "workflow run metadata", context.limits);
+	const timestamp = context.now();
+	const previousRun = await getRequiredRun(context.store, runId);
+	const updatedRun = await updateRunMetadataIfCurrent(context.store, runId, persistedMetadata, timestamp);
 	lifecycle.emitRunMetadataUpdated(updatedRun, previousRun);
 	return updatedRun;
 }
-async function setWorkflowRunAttributes(service, runId, attributes) {
-	const normalized = normalizeWorkflowAttributePatch(attributes);
-	const timestamp = service.now();
-	return await setRunAttributesIfCurrent(service.store, runId, normalized, timestamp);
+async function setRunAttributes(context, runId, attributes) {
+	const normalized = normalizeAttributePatch(attributes);
+	const timestamp = context.now();
+	return await setRunAttributesIfCurrent(context.store, runId, normalized, timestamp);
 }
-async function cancelWorkflowRun(service, lifecycle, runId) {
-	const previousRun = await getRequiredRun(service.store, runId);
-	const canceledRun = await cancelRunWithChildren(service.store, runId, service.now());
+async function cancelWorkflowRun(context, lifecycle, runId) {
+	const previousRun = await getRequiredRun(context.store, runId);
+	const canceledRun = await cancelRunWithChildren(context.store, runId, context.now());
 	if (previousRun.status !== "canceled") await lifecycle.emitLifecycleEvent(canceledRun, previousRun);
 	return canceledRun;
 }
-async function resolveWorkflowVersion(workflowName, fallbackVersion, resolver) {
+async function resolveVersion(workflowName, fallbackVersion, resolver) {
 	if (resolver === void 0) return fallbackVersion;
-	const resolved = await resolver(workflowName, defineWorkflowFromName(workflowName, fallbackVersion));
-	return typeof resolved === "string" && resolved.trim() !== "" ? resolved : fallbackVersion;
+	const resolved = await resolver(workflowName, defineFromName(workflowName, fallbackVersion));
+	return resolved !== void 0 && resolved.trim() !== "" ? resolved : fallbackVersion;
 }
-async function resolveWorkflowStartSpec(definition, options) {
-	const version = await resolveWorkflowVersion(definition.name, options?.workflowVersion ?? definition.version, options?.workflowVersionResolver);
+async function resolveStartSpec(definition, options) {
+	const version = await resolveVersion(definition.name, options?.workflowVersion ?? definition.version, options?.workflowVersionResolver);
 	if (version === definition.version) return definition;
 	return {
 		...definition,
 		version,
 		config: {
 			...definition.config,
-			...version === void 0 ? { version: void 0 } : { version }
+			version
 		}
 	};
 }
+async function cleanupRuns(context, options) {
+	const result = await context.store.cleanupRuns(options);
+	context.observation.emitCleanupCompleted(result);
+	return result;
+}
+async function applyRetentionPolicy(context, options) {
+	const result = await context.store.cleanupRuns(retentionCleanupOptions(options, context.now));
+	context.observation.emitRetentionApplied(result);
+	return result;
+}
 //#endregion
-export { cancelWorkflowRun, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rerunWorkflowRun, rescheduleWorkflowRun, resolveRerunWorkflowDefinition, resolveWorkflowStartSpec, resolveWorkflowVersion, retryFailedWorkflowRun, setWorkflowRunAttributes, updateWorkflowRunMetadata };
+export { applyRetentionPolicy, cancelWorkflowRun, cleanupRuns, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rerunRun, rescheduleWorkflowRun, resolveStartSpec, retryFailedWorkflowRun, setRunAttributes, updateWorkflowRunMetadata };

package/dist/engine/run-utils.d.mts

@@ -1,16 +1,14 @@
-import { RunId } from "../types/run-id.mjs";
+import { RunId } from "../types/ids.mjs";
 import { CleanupRunsOptions, RetentionPolicyOptions } from "../types/cleanup.mjs";
 import { WorkflowDefinition } from "../types/definition.mjs";
-import { CompletedResult, ExecutionResult, HandleOperations, WorkflowHandle } from "../types/result.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { WorkflowEventReader, WorkflowRunReaderRepository } from "../types/store.mjs";
+import { CompletedResult, ExecutionResult } from "../types/result.mjs";
+import { RunRecord } from "../types/run.mjs";
+import { WorkflowStore } from "../types/store.mjs";
 //#region src/engine/run-utils.d.ts
-type WorkflowRunLookup = WorkflowRunReaderRepository;
-type WorkflowHandleStore = WorkflowRunLookup & WorkflowEventReader;
-declare function retentionCleanupOptions(options: RetentionPolicyOptions, engineNow: () => Temporal.Instant): CleanupRunsOptions;
-declare function workflowHandle<TOutput>(store: WorkflowHandleStore, definition: WorkflowDefinition<unknown, TOutput>, runId: RunId, now: () => Temporal.Instant, operations: HandleOperations): WorkflowHandle<TOutput>;
-declare function readRunResult<TOutput>(store: WorkflowRunLookup, runId: RunId, fallbackAvailableAt: Temporal.Instant): Promise<ExecutionResult<TOutput>>;
-declare function makeCompletedRunResult<TOutput>(run: WorkflowRunRecord): CompletedResult<TOutput>;
-declare function makeCanceledRunResult<TOutput>(run: WorkflowRunRecord): ExecutionResult<TOutput>;
-//#endregion
-export { makeCanceledRunResult, makeCompletedRunResult, readRunResult, retentionCleanupOptions, workflowHandle };
+export declare function retentionCleanupOptions(options: RetentionPolicyOptions, engineNow: () => Temporal.Instant): CleanupRunsOptions;
+export declare function readRunResult<TOutput>(store: WorkflowStore, definition: WorkflowDefinition<unknown, TOutput, unknown>, runId: RunId, fallbackAvailableAt: Temporal.Instant): Promise<ExecutionResult<TOutput>>;
+/** The result of a run that has not completed: failed, canceled, or still waiting. */
+export declare function unfinishedRunResult<TOutput>(run: RunRecord, fallbackAvailableAt: Temporal.Instant): ExecutionResult<TOutput>;
+export declare function makeCompletedRunResult<TOutput>(definition: WorkflowDefinition<unknown, TOutput, unknown>, run: RunRecord): CompletedResult<TOutput>;
+export declare function makeCanceledRunResult<TOutput>(run: RunRecord): ExecutionResult<TOutput>;
+//#endregion

package/dist/engine/run-utils.mjs

@@ -1,61 +1,36 @@
 import { WorkflowRunCanceledError } from "../errors/run.mjs";
-import { getRequiredRun } from "../utility.mjs";
 import "../errors/mod.mjs";
+import { getRequiredRun } from "../store/query.mjs";
 import { serializeError } from "./serialization.mjs";
+import { requireDefinitionMatchesRun } from "./state.mjs";
 //#region src/engine/run-utils.ts
 function retentionCleanupOptions(options, engineNow) {
 	return {
 		finishedAtBefore: (options.now === void 0 ? engineNow() : options.now).toZonedDateTimeISO("UTC").subtract(options.olderThan).toInstant(),
-		...options.status === void 0 ? {} : { status: options.status },
-		...options.workflowName === void 0 ? {} : { workflowName: options.workflowName },
-		...options.workflowVersion === void 0 ? {} : { workflowVersion: options.workflowVersion },
-		...options.idempotencyKey === void 0 ? {} : { idempotencyKey: options.idempotencyKey },
-		...options.parentRunId === void 0 ? {} : { parentRunId: options.parentRunId },
-		...options.parentStepId === void 0 ? {} : { parentStepId: options.parentStepId },
-		...options.parentStepName === void 0 ? {} : { parentStepName: options.parentStepName },
-		...options.parentStepAttempt === void 0 ? {} : { parentStepAttempt: options.parentStepAttempt },
-		...options.dryRun === void 0 ? {} : { dryRun: options.dryRun },
-		...options.limit === void 0 ? {} : { limit: options.limit }
+		status: options.status,
+		workflowName: options.workflowName,
+		workflowVersion: options.workflowVersion,
+		idempotencyKey: options.idempotencyKey,
+		parentRunId: options.parentRunId,
+		parentStepId: options.parentStepId,
+		parentStepName: options.parentStepName,
+		parentStepAttempt: options.parentStepAttempt,
+		dryRun: options.dryRun,
+		limit: options.limit
 	};
 }
-function workflowHandle(store, definition, runId, now, operations) {
-	return {
-		runId,
-		workflowName: definition.name,
-		...definition.version === void 0 ? {} : { workflowVersion: definition.version },
-		async getRun() {
-			return await getRequiredRun(store, runId);
-		},
-		async status() {
-			return (await getRequiredRun(store, runId)).status;
-		},
-		async events() {
-			return await store.getEvents(runId);
-		},
-		async timeline() {
-			return await operations.getTimeline(runId);
-		},
-		result: async () => await readRunResult(store, runId, now()),
-		async setMetadata(metadata) {
-			return await operations.setMetadata(runId, metadata);
-		},
-		async setAttributes(attributes) {
-			return await operations.setAttributes(runId, attributes);
-		},
-		async cancel() {
-			return await operations.cancel(runId);
-		}
-	};
-}
-async function readRunResult(store, runId, fallbackAvailableAt) {
+async function readRunResult(store, definition, runId, fallbackAvailableAt) {
 	const run = await getRequiredRun(store, runId);
-	if (run.status === "completed") return makeCompletedRunResult(run);
+	return run.status === "completed" ? makeCompletedRunResult(definition, run) : unfinishedRunResult(run, fallbackAvailableAt);
+}
+/** The result of a run that has not completed: failed, canceled, or still waiting. */
+function unfinishedRunResult(run, fallbackAvailableAt) {
 	if (run.status === "failed") return {
 		kind: "failed",
 		run,
 		error: run.error ?? {
 			name: "WorkflowError",
-			message: `Workflow run failed: ${runId}`
+			message: `Workflow run failed: ${run.id}`
 		}
 	};
 	if (run.status === "canceled") return makeCanceledRunResult(run);
@@ -65,7 +40,9 @@ async function readRunResult(store, runId, fallbackAvailableAt) {
 		availableAt: run.availableAt ?? fallbackAvailableAt
 	};
 }
-function makeCompletedRunResult(run) {
+function makeCompletedRunResult(definition, run) {
+	requireDefinitionMatchesRun(definition, run);
+	if (run.status !== "completed") throw new TypeError("A completed workflow result requires a completed run");
 	return {
 		kind: "completed",
 		run,
@@ -76,8 +53,8 @@ function makeCanceledRunResult(run) {
 	return {
 		kind: "failed",
 		run,
-		error: run.error ?? serializeError(WorkflowRunCanceledError.create(run.id))
+		error: run.error ?? serializeError(new WorkflowRunCanceledError(run.id))
 	};
 }
 //#endregion
-export { makeCanceledRunResult, makeCompletedRunResult, readRunResult, retentionCleanupOptions, workflowHandle };
+export { makeCanceledRunResult, makeCompletedRunResult, readRunResult, retentionCleanupOptions, unfinishedRunResult };

package/dist/engine/schedule.d.mts

@@ -1,25 +1,11 @@
-import { RunId } from "../types/run-id.mjs";
 import { ScheduleConfig, ScheduleId, ScheduleRecord, ScheduleStatus, TickSchedulesOptions, TickSchedulesResult } from "../types/schedule.mjs";
 import { WorkflowDefinition } from "../types/definition.mjs";
-import "../types/run.mjs";
-import { WorkflowRunReaderRepository, WorkflowScheduleConditionalWriterRepository, WorkflowScheduleCreationRepository, WorkflowScheduleListerRepository, WorkflowScheduleReaderRepository, WorkflowStoreNamespace } from "../types/store.mjs";
-import { WorkflowExecutionLimits } from "../types/engine-options.mjs";
-import { WorkflowRunCanceler, WorkflowRunStarter, WorkflowScheduleRunObserver } from "../types/engine.mjs";
+import { WorkflowStore } from "../types/store.mjs";
+import { ExecutionLimits } from "../types/engine-options.mjs";
+import { WorkflowEngine } from "./create.mjs";
 //#region src/engine/schedule.d.ts
-type WorkflowScheduleCommandStore = WorkflowStoreNamespace & WorkflowScheduleCreationRepository & WorkflowScheduleReaderRepository & WorkflowScheduleConditionalWriterRepository;
-type WorkflowScheduleTickStore = WorkflowScheduleListerRepository & WorkflowScheduleConditionalWriterRepository & WorkflowRunReaderRepository;
-type WorkflowScheduleTickEngine = WorkflowRunStarter & WorkflowRunCanceler & Partial<WorkflowScheduleRunObserver>;
-declare function resolveScheduleRecord<TInput, TOutput, TRawInput>(namespace: string, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: ScheduleConfig<TInput, TRawInput>, createdAt: Temporal.Instant, limits: WorkflowExecutionLimits): ScheduleRecord<TInput>;
-declare function upsertSchedule<TInput, TOutput, TRawInput>(store: WorkflowScheduleCommandStore, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: ScheduleConfig<TInput, TRawInput>, timestamp: Temporal.Instant, limits: WorkflowExecutionLimits): Promise<ScheduleRecord<TInput>>;
-declare function updateScheduleStatus(store: WorkflowScheduleReaderRepository & WorkflowScheduleConditionalWriterRepository, scheduleId: ScheduleId, status: ScheduleStatus, now: Temporal.Instant): Promise<ScheduleRecord>;
-declare function workflowScheduleFireTimes(schedule: ScheduleRecord, now: Temporal.Instant): readonly Temporal.Instant[];
-declare function advanceSchedule(store: WorkflowScheduleConditionalWriterRepository, schedule: ScheduleRecord, now: Temporal.Instant, updatedAt: Temporal.Instant, fired?: {
-  readonly fireAt: Temporal.Instant;
-  readonly runId: RunId;
-}): Promise<ScheduleRecord | undefined>;
-declare function bufferSchedule(store: WorkflowScheduleConditionalWriterRepository, schedule: ScheduleRecord, fireTimes: readonly Temporal.Instant[], now: Temporal.Instant, updatedAt: Temporal.Instant): Promise<ScheduleRecord | undefined>;
-declare function hasActiveScheduledRun(store: WorkflowRunReaderRepository, schedule: ScheduleRecord): Promise<boolean>;
-declare function cancelActiveScheduledRun(store: WorkflowRunReaderRepository, engine: WorkflowRunCanceler, schedule: ScheduleRecord): Promise<void>;
-declare function tickSchedules(store: WorkflowScheduleTickStore, engine: WorkflowScheduleTickEngine, now: () => Temporal.Instant, tickOptions: TickSchedulesOptions | undefined): Promise<TickSchedulesResult>;
-//#endregion
-export { advanceSchedule, bufferSchedule, cancelActiveScheduledRun, hasActiveScheduledRun, resolveScheduleRecord, tickSchedules, updateScheduleStatus, upsertSchedule, workflowScheduleFireTimes };
+export declare function resolveScheduleRecord<TInput, TOutput, TRawInput>(namespace: string, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: ScheduleConfig<TInput, TRawInput>, createdAt: Temporal.Instant, limits: ExecutionLimits): Promise<ScheduleRecord>;
+export declare function upsertSchedule<TInput, TOutput, TRawInput>(store: WorkflowStore, definition: WorkflowDefinition<TInput, TOutput, TRawInput>, options: ScheduleConfig<TInput, TRawInput>, timestamp: Temporal.Instant, limits: ExecutionLimits): Promise<ScheduleRecord>;
+export declare function updateScheduleStatus(store: WorkflowStore, scheduleId: ScheduleId, status: ScheduleStatus, now: Temporal.Instant): Promise<ScheduleRecord>;
+export declare function tickSchedules(store: WorkflowStore, engine: WorkflowEngine, now: () => Temporal.Instant, tickOptions: TickSchedulesOptions | undefined): Promise<TickSchedulesResult>;
+//#endregion

package/dist/engine/schedule.mjs

@@ -1,45 +1,50 @@
-import { isActiveWorkflowRunStatus } from "../utility.mjs";
-import { WorkflowScheduleAlreadyExistsError, WorkflowScheduleError } from "../errors/schedule.mjs";
+import { WorkflowErrorCode } from "../errors/codes.mjs";
+import { WorkflowScheduleError } from "../errors/schedule.mjs";
+import { matchesWorkflowError } from "../errors/records.mjs";
 import "../errors/mod.mjs";
-import { defineWorkflowFromName } from "../definition.mjs";
-import { toOptionalPersistedValue, toPersistedValue } from "./serialization.mjs";
+import { defineFromName } from "../definition.mjs";
+import { isActiveRunStatus } from "../run-status.mjs";
+import { enforceStorageValueSize, parseInput, toPersistedValue } from "./serialization.mjs";
+import { cancelWorkflowRun } from "./run-service.mjs";
+import { isPlainObject } from "@temelj/value";
 //#region src/engine/schedule.ts
 const MAX_SCHEDULE_UPSERT_ATTEMPTS = 3;
-function resolveScheduleRecord(namespace, definition, options, createdAt, limits) {
+async function resolveScheduleRecord(namespace, definition, options, createdAt, limits) {
 	const nextFireAt = (options.from ?? createdAt).toZonedDateTimeISO("UTC").add(options.every).toInstant();
 	const endAt = options.endAt;
 	const catchUp = options.catchUp ?? "one";
 	const maxCatchUpRuns = options.maxCatchUpRuns;
 	const overlap = options.overlap ?? "allow";
-	const persistedInput = toOptionalPersistedValue(options.input, "workflow schedule input", limits);
+	const persistedInput = await parseInput(definition, options.input);
+	enforceStorageValueSize(persistedInput, "workflow schedule input", limits);
 	return {
 		id: options.id,
 		namespace,
 		workflowName: definition.name,
-		...definition.version === void 0 ? {} : { workflowVersion: definition.version },
-		...persistedInput === void 0 ? {} : { input: persistedInput },
-		...options.context === void 0 ? {} : { context: toPersistedValue(options.context, "workflow schedule context", limits) },
+		workflowVersion: definition.version,
+		input: persistedInput,
+		context: options.context !== void 0 ? toPersistedValue(options.context, "workflow schedule context", limits) : void 0,
 		status: endAt !== void 0 && Temporal.Instant.compare(nextFireAt, endAt) > 0 ? "deleted" : "active",
 		every: options.every,
 		catchUp,
-		...maxCatchUpRuns === void 0 ? {} : { maxCatchUpRuns },
-		...options.maxLateness === void 0 ? {} : { maxLateness: options.maxLateness },
+		maxCatchUpRuns,
+		maxLateness: options.maxLateness,
 		overlap,
 		createdAt,
 		updatedAt: createdAt,
 		nextFireAt,
-		...endAt === void 0 ? {} : { endAt },
+		endAt,
 		tickCount: 0
 	};
 }
 async function upsertSchedule(store, definition, options, timestamp, limits) {
-	const schedule = resolveScheduleRecord(store.namespace, definition, options, timestamp, limits);
+	const schedule = await resolveScheduleRecord(store.namespace, definition, options, timestamp, limits);
 	for (let attempt = 0; attempt < MAX_SCHEDULE_UPSERT_ATTEMPTS; attempt += 1) {
 		const existing = await store.getSchedule(schedule.id);
 		if (existing === void 0) try {
 			return await store.createSchedule(schedule);
 		} catch (error) {
-			if (!WorkflowScheduleAlreadyExistsError.isAlreadyExists(error, schedule.id)) throw error;
+			if (!matchesWorkflowError(error, WorkflowErrorCode.SCHEDULE_ALREADY_EXISTS, { scheduleId: schedule.id })) throw error;
 			continue;
 		}
 		const next = {
@@ -47,25 +52,25 @@ async function upsertSchedule(store, definition, options, timestamp, limits) {
 			createdAt: existing.createdAt,
 			updatedAt: timestamp,
 			tickCount: existing.tickCount,
-			...existing.bufferedFireAt === void 0 ? {} : { bufferedFireAt: existing.bufferedFireAt },
-			...existing.lastFireAt === void 0 ? {} : { lastFireAt: existing.lastFireAt },
-			...existing.lastRunId === void 0 ? {} : { lastRunId: existing.lastRunId }
+			bufferedFireAt: existing.bufferedFireAt,
+			lastFireAt: existing.lastFireAt,
+			lastRunId: existing.lastRunId
 		};
 		const updated = await store.updateScheduleIfCurrent(existing, next);
 		if (updated !== void 0) return updated;
 	}
-	WorkflowScheduleError.upsertConflictExhausted(schedule.id);
+	throw new WorkflowScheduleError(`Failed to upsert workflow schedule ${schedule.id}`, WorkflowErrorCode.SCHEDULE_UPSERT_CONFLICT_EXHAUSTED, { scheduleId: schedule.id });
 }
 async function updateScheduleStatus(store, scheduleId, status, now) {
 	const current = await store.getSchedule(scheduleId);
-	if (current === void 0) WorkflowScheduleError.notFound(scheduleId);
+	if (current === void 0) throw new WorkflowScheduleError(`Workflow schedule not found: ${scheduleId}`, WorkflowErrorCode.SCHEDULE_NOT_FOUND, { scheduleId });
 	const next = {
 		...current,
 		status,
 		updatedAt: now
 	};
 	const updated = await store.updateScheduleIfCurrent(current, next);
-	if (updated === void 0) WorkflowScheduleError.updateConflictExhausted(scheduleId);
+	if (updated === void 0) throw new WorkflowScheduleError(`Failed to update workflow schedule ${scheduleId}`, WorkflowErrorCode.SCHEDULE_UPDATE_CONFLICT_EXHAUSTED, { scheduleId });
 	return updated;
 }
 function workflowScheduleFireTimes(schedule, now) {
@@ -95,11 +100,9 @@ async function advanceSchedule(store, schedule, now, updatedAt, fired) {
 		status: schedule.endAt !== void 0 && Temporal.Instant.compare(nextFireAt, schedule.endAt) > 0 ? "deleted" : schedule.status,
 		updatedAt,
 		tickCount: schedule.tickCount + (fired === void 0 ? 0 : 1),
-		...fired === void 0 || schedule.bufferedFireAt === void 0 ? {} : { bufferedFireAt: void 0 },
-		...fired === void 0 ? {} : {
-			lastFireAt: fired.fireAt,
-			lastRunId: fired.runId
-		}
+		bufferedFireAt: fired === void 0 ? schedule.bufferedFireAt : void 0,
+		lastFireAt: fired === void 0 ? schedule.lastFireAt : fired.fireAt,
+		lastRunId: fired === void 0 ? schedule.lastRunId : fired.runId
 	};
 	return await store.updateScheduleIfCurrent(schedule, next);
 }
@@ -111,19 +114,19 @@ async function bufferSchedule(store, schedule, fireTimes, now, updatedAt) {
 		nextFireAt,
 		status: schedule.endAt !== void 0 && Temporal.Instant.compare(nextFireAt, schedule.endAt) > 0 ? "deleted" : schedule.status,
 		updatedAt,
-		...bufferAt === void 0 ? {} : { bufferedFireAt: bufferAt }
+		bufferedFireAt: bufferAt
 	};
 	return await store.updateScheduleIfCurrent(schedule, next);
 }
 async function hasActiveScheduledRun(store, schedule) {
 	if (schedule.lastRunId === void 0) return false;
 	const run = await store.getRun(schedule.lastRunId);
-	return run !== void 0 && isActiveWorkflowRunStatus(run.status);
+	return run !== void 0 && isActiveRunStatus(run.status);
 }
 async function cancelActiveScheduledRun(store, engine, schedule) {
 	if (schedule.lastRunId === void 0) return;
 	const run = await store.getRun(schedule.lastRunId);
-	if (run !== void 0 && isActiveWorkflowRunStatus(run.status)) await engine.cancelRun(schedule.lastRunId);
+	if (run !== void 0 && isActiveRunStatus(run.status)) await cancelWorkflowRun(engine.context, engine.lifecycle, schedule.lastRunId);
 }
 async function tickSchedules(store, engine, now, tickOptions) {
 	const tickNow = tickOptions?.now === void 0 ? now() : tickOptions.now;
@@ -153,7 +156,7 @@ async function tickSchedules(store, engine, now, tickOptions) {
 			continue;
 		}
 		for (const fireAt of fireTimes) {
-			const run = await engine.startWorkflow(defineWorkflowFromName(schedule.workflowName, schedule.workflowVersion), schedule.input, {
+			const run = await engine.startWorkflow(defineFromName(schedule.workflowName, schedule.workflowVersion), schedule.input, {
 				idempotencyKey: `schedule:${schedule.id}:${fireAt.toString()}`,
 				availableAt: fireAt,
 				context: scheduleRunContext(schedule, fireAt)
@@ -166,11 +169,11 @@ async function tickSchedules(store, engine, now, tickOptions) {
 			currentSchedule = advanced;
 			advancedSchedule = true;
 			runIds.push(run.runId);
-			engine.observeScheduleRunCreated?.({
+			engine.observation.emitScheduleRunCreated({
 				scheduleId: schedule.id,
 				runId: run.runId,
 				workflowName: schedule.workflowName,
-				...schedule.workflowVersion === void 0 ? {} : { workflowVersion: schedule.workflowVersion },
+				workflowVersion: schedule.workflowVersion,
 				fireAt,
 				timestamp: tickNow
 			});
@@ -185,7 +188,7 @@ async function tickSchedules(store, engine, now, tickOptions) {
 		ticked: runIds.length,
 		runIds,
 		scheduleIds,
-		...nextScheduleAt === void 0 ? {} : { nextScheduleAt }
+		nextScheduleAt
 	};
 }
 function scheduleRunContext(schedule, fireAt) {
@@ -193,7 +196,7 @@ function scheduleRunContext(schedule, fireAt) {
 		scheduleId: schedule.id,
 		scheduleFireAt: fireAt.toString()
 	};
-	if (typeof schedule.context === "object" && schedule.context !== null && !Array.isArray(schedule.context) && (Object.getPrototypeOf(schedule.context) === Object.prototype || Object.getPrototypeOf(schedule.context) === null)) return Object.assign({}, schedule.context, {
+	if (isPlainObject(schedule.context)) return Object.assign({}, schedule.context, {
 		scheduleId: schedule.id,
 		scheduleFireAt: fireAt.toString()
 	});
@@ -204,4 +207,4 @@ function scheduleRunContext(schedule, fireAt) {
 	};
 }
 //#endregion
-export { advanceSchedule, bufferSchedule, cancelActiveScheduledRun, hasActiveScheduledRun, resolveScheduleRecord, tickSchedules, updateScheduleStatus, upsertSchedule, workflowScheduleFireTimes };
+export { resolveScheduleRecord, tickSchedules, updateScheduleStatus, upsertSchedule };