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

package/dist/engine/create.mjs

@@ -1,20 +1,18 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowOptionsError } from "../errors/base.mjs";
-import { createDefaultRunIdFactory, createDefaultWorkflowRecordedIdFactory } from "../utility.mjs";
-import { defineWorkflowFromTarget } from "../definition.mjs";
-import { readRunResult, retentionCleanupOptions } from "./run-utils.mjs";
-import { cancelWorkflowRun, markWorkflowRunPermanentlyFailed, releaseStaleWorkflowRunLease, rerunWorkflowRun, rescheduleWorkflowRun, retryFailedWorkflowRun, setWorkflowRunAttributes, updateWorkflowRunMetadata } from "./run-service.mjs";
-import { createWorkflowEngineStartApi } from "./start-api.mjs";
+import { defineFromTarget } from "../definition.mjs";
+import { createDefaultRecordedIdFactory, createDefaultRunIdFactory } from "../ids.mjs";
+import { getWorkflowRunSummary } from "./inspection.mjs";
+import { readRunResult } from "./run-utils.mjs";
+import { rerunRun } from "./run-service.mjs";
+import { acquireLock, releaseLock } from "./lock.mjs";
+import { resolveScheduleRecord, tickSchedules } from "./schedule.mjs";
+import { getRunRef, resolveScheduleNextOptions, startRun } from "./start.mjs";
 import { createWorkflowStore } from "../store/create.mjs";
-import { instrumentWorkflowStorage } from "../store/instrumentation.mjs";
-import { broadcastWorkflowMessageInput, sendWorkflowMessageInput } from "./message.mjs";
-import { disposeHook, disposeWebhook, getHookByToken, resumeHook, resumeWebhook } from "./hooks.mjs";
-import { acquireLock, releaseLock, releaseStaleLock } from "./lock.mjs";
-import { followStreamForRun, getStreamInfoForRun, readStreamForRun, readStreamPageForRun, waitForStreamChunkForRun, waitForStreamForRun, waitForStreamTerminalForRun } from "./stream.mjs";
-import { createWorkflowEngineExecutionApi } from "./execution-api.mjs";
-import { createWorkflowEngineInspectionApi } from "./inspection-api.mjs";
-import { createWorkflowLifecycleEmitter } from "./lifecycle.mjs";
+import { instrumentStorage } from "../store/instrumentation.mjs";
+import { createLifecycleEmitter } from "./lifecycle.mjs";
 import { createObservationEmitter } from "./observation.mjs";
-import { resolveScheduleRecord, tickSchedules, updateScheduleStatus, upsertSchedule } from "./schedule.mjs";
+import { resumeRun } from "./resume.mjs";
 import { createStorage } from "@temelj/storage";
 import { createNoopLogger } from "@temelj/log";
 //#region src/engine/create.ts
@@ -33,11 +31,10 @@ function defaultDeterministicBytes(context) {
 	}
 	return bytes;
 }
-/** Creates workflow engine. */
 function createWorkflowEngine(options = {}) {
 	return new WorkflowEngine(options);
 }
-/** Storage-backed workflow engine implementation used by the default client and runtime. */
+/** Executes workflows against a store; the client and workers build on it. */
 var WorkflowEngine = class {
 	storage;
 	store;
@@ -45,25 +42,21 @@ var WorkflowEngine = class {
 	#limits;
 	#logger;
 	#telemetry;
-	#observation;
-	#startApi;
-	#executionApi;
-	#inspectionApi;
-	#hookService;
-	#messageService;
-	#streamService;
-	#runService;
-	#runLifecycle;
+	observation;
+	#resumeServices;
+	/** Shared by the engine's services and the client facades. */
+	context;
+	lifecycle;
 	constructor(options = {}) {
-		if (options.store !== void 0 && options.storage !== void 0) WorkflowOptionsError.engineStoreAndStorageConflict();
+		if (options.store !== void 0 && options.storage !== void 0) throw new WorkflowOptionsError("Workflow engine options cannot include both store and storage", { code: WorkflowErrorCode.OPTIONS_ENGINE_STORE_STORAGE_CONFLICT });
 		const telemetry = options.telemetry === false ? void 0 : options.telemetry;
-		const storage = options.store === void 0 ? instrumentWorkflowStorage(options.storage ?? createStorage(), telemetry) : void 0;
+		const storage = options.store === void 0 ? instrumentStorage(options.storage ?? createStorage(), telemetry) : void 0;
 		this.store = options.store ?? createWorkflowStore({ storage });
 		this.storage = this.store.storage;
 		const now = options.now ?? Temporal.Now.instant;
 		this.#now = now;
 		const createRunId = options.createRunId ?? createDefaultRunIdFactory(now);
-		const createRecordedId = options.createRecordedId ?? createDefaultWorkflowRecordedIdFactory(createRunId);
+		const createRecordedId = options.createRecordedId ?? createDefaultRecordedIdFactory(createRunId);
 		const createDeterministicRandom = options.createDeterministicRandom ?? defaultDeterministicRandom;
 		const createDeterministicUuid = options.createDeterministicUuid ?? defaultDeterministicUuid;
 		const createDeterministicBytes = options.createDeterministicBytes ?? defaultDeterministicBytes;
@@ -74,40 +67,26 @@ var WorkflowEngine = class {
 			maximumStreamChunks: options.maximumStreamChunks
 		};
 		this.#limits = limits;
-		const readCurrentRunResult = async (runId) => await readRunResult(this.store, runId, now());
+		const readCurrentRunResult = async (definition, runId) => await readRunResult(this.store, definition, runId, now());
 		const logger = options.logger === false ? createNoopLogger() : options.logger ?? createNoopLogger();
 		this.#telemetry = telemetry;
 		this.#logger = logger;
 		const observation = createObservationEmitter(telemetry);
-		this.#observation = observation;
-		this.#hookService = {
+		this.observation = observation;
+		this.context = {
 			store: this.store,
 			now,
 			limits,
-			emitMessageSent: observation.emitMessageSent,
-			emitHookResumed: observation.emitHookResumed,
-			emitWebhookResumed: observation.emitWebhookResumed,
-			telemetry
-		};
-		this.#messageService = {
-			store: this.store,
-			now,
-			limits,
-			observeMessageSent: observation.emitMessageSent,
-			telemetry
-		};
-		this.#streamService = { store: this.store };
-		this.#runService = {
-			store: this.store,
-			now,
-			limits
+			observation,
+			telemetry,
+			logger,
+			createRunId
 		};
-		const { emitLifecycleEvent, emitResultLifecycleEvent } = createWorkflowLifecycleEmitter(options, observation);
-		this.#runLifecycle = {
+		const { emitLifecycleEvent, emitResultLifecycleEvent } = createLifecycleEmitter(options, observation);
+		this.lifecycle = {
 			emitLifecycleEvent,
 			emitRunMetadataUpdated: observation.emitRunMetadataUpdated
 		};
-		this.#inspectionApi = createWorkflowEngineInspectionApi(this.store, now);
 		const executionService = {
 			store: this.store,
 			now,
@@ -130,51 +109,15 @@ var WorkflowEngine = class {
 				event
 			})
 		};
-		this.#executionApi = createWorkflowEngineExecutionApi({
-			store: this.store,
-			now,
+		this.#resumeServices = {
+			context: this.context,
 			executionService,
-			emitResultLifecycleEvent,
-			starter: this,
-			resumer: this
-		});
-		this.#startApi = createWorkflowEngineStartApi({
-			store: this.store,
-			now,
-			limits,
-			createRunId,
-			telemetry,
-			emitRunEvent: observation.emitRunEvent,
-			starter: this,
-			handleOperations: {
-				getTimeline: async (runId) => await this.getTimeline(runId),
-				setMetadata: async (runId, metadata) => await this.updateRunMetadata(runId, metadata),
-				setAttributes: async (runId, attributes) => await this.setRunAttributes(runId, attributes),
-				cancel: async (runId) => await this.cancelRun(runId)
-			}
-		});
+			emitResultLifecycleEvent
+		};
 		try {
 			telemetry?.bindEngine?.(this);
 		} catch {}
 	}
-	on(pattern, handler) {
-		return this.#observation.on(pattern, handler);
-	}
-	once(pattern, handler) {
-		return this.#observation.once(pattern, handler);
-	}
-	off(pattern, handler) {
-		return this.#observation.off(pattern, handler);
-	}
-	listeners(pattern) {
-		return pattern === void 0 ? this.#observation.listeners() : this.#observation.listeners(pattern);
-	}
-	clearListeners(pattern) {
-		return this.#observation.clearListeners(pattern);
-	}
-	listenerCount(pattern) {
-		return this.#observation.listenerCount(pattern);
-	}
 	async close() {
 		const errors = [];
 		try {
@@ -189,50 +132,25 @@ var WorkflowEngine = class {
 		}
 		if (errors.length > 0) throw errors[0];
 	}
-	observeWorkerOperation(event) {
-		this.#observation.emitWorkerOperation(event);
-	}
-	observeScheduleRunCreated(event) {
-		this.#observation.emitScheduleRunCreated(event);
-	}
 	async startWorkflow(workflow, input, options) {
-		return this.#startApi.startWorkflow(workflow, input, options);
+		return await startRun(this, workflow, input, options);
 	}
 	async startWorkflows(workflow, items) {
-		return this.#startApi.startWorkflows(workflow, items);
+		const handles = [];
+		for (const item of items) handles.push(await this.startWorkflow(workflow, item.input, item.options));
+		return handles;
+	}
+	async getRunRef(runId) {
+		return await getRunRef(this, runId);
 	}
 	async scheduleNextWorkflow(workflow, input, options) {
-		return this.#startApi.scheduleNextWorkflow(workflow, input, options);
+		return await this.startWorkflow(workflow, input, resolveScheduleNextOptions(options, this.context.now).start);
 	}
 	async createSchedule(workflow, scheduleOptions) {
-		const definition = defineWorkflowFromTarget(workflow);
-		const schedule = resolveScheduleRecord(this.store.namespace, definition, scheduleOptions, this.#now(), this.#limits);
+		const definition = defineFromTarget(workflow);
+		const schedule = await resolveScheduleRecord(this.store.namespace, definition, scheduleOptions, this.#now(), this.#limits);
 		return this.store.createSchedule(schedule);
 	}
-	async upsertSchedule(workflow, scheduleOptions) {
-		return upsertSchedule(this.store, defineWorkflowFromTarget(workflow), scheduleOptions, this.#now(), this.#limits);
-	}
-	async getSchedule(scheduleId) {
-		return this.store.getSchedule(scheduleId);
-	}
-	async listSchedules(options) {
-		return this.store.listSchedules(options);
-	}
-	async listSchedulesPage(options) {
-		return this.store.listSchedulesPage(options);
-	}
-	async pauseSchedule(scheduleId) {
-		return updateScheduleStatus(this.store, scheduleId, "paused", this.#now());
-	}
-	async resumeSchedule(scheduleId) {
-		return updateScheduleStatus(this.store, scheduleId, "active", this.#now());
-	}
-	async archiveSchedule(scheduleId) {
-		return updateScheduleStatus(this.store, scheduleId, "archived", this.#now());
-	}
-	async deleteSchedule(scheduleId) {
-		return updateScheduleStatus(this.store, scheduleId, "deleted", this.#now());
-	}
 	async tickSchedules(options) {
 		const timestamp = options?.now ?? this.#now();
 		const tickOptions = options === void 0 ? { now: timestamp } : {
@@ -240,7 +158,7 @@ var WorkflowEngine = class {
 			now: timestamp
 		};
 		const result = await tickSchedules(this.store, this, this.#now, tickOptions);
-		this.#observation.emitScheduleTicked({
+		this.observation.emitScheduleTicked({
 			result,
 			timestamp
 		});
@@ -250,152 +168,29 @@ var WorkflowEngine = class {
 		const acquiredAt = options.now === void 0 ? this.#now() : options.now;
 		return acquireLock(this.store, key, options, acquiredAt);
 	}
-	async getLock(key) {
-		return this.store.getLock(key);
-	}
-	async listLocks() {
-		return this.store.listLocks();
-	}
 	async releaseLock(key, options) {
 		const releasedAt = options.now === void 0 ? this.#now() : options.now;
 		return releaseLock(this.store, key, options, releasedAt);
 	}
-	async releaseStaleLock(key, options) {
-		const releasedAt = options?.now === void 0 ? this.#now() : options.now;
-		return releaseStaleLock(this.store, key, releasedAt);
-	}
 	async runWorkflow(implementation, input, options) {
-		return this.#executionApi.runWorkflow(implementation, input, options);
+		return await this.startWorkflow(implementation.definition, input, options?.start);
 	}
 	async runWorkflowNow(implementation, input, options) {
-		return this.#executionApi.runWorkflowNow(implementation, input, options);
+		const handle = await this.startWorkflow(implementation.definition, input, options?.start);
+		return await this.resumeWorkflow(implementation, handle.runId, { signal: options?.signal });
 	}
 	async resumeWorkflow(implementation, runId, options) {
-		return this.#executionApi.resumeWorkflow(implementation, runId, options);
-	}
-	async getRun(runId) {
-		return this.#inspectionApi.getRun(runId);
-	}
-	async getEvents(runId) {
-		return this.#inspectionApi.getEvents(runId);
-	}
-	async listEventsPage(runId, options) {
-		return this.#inspectionApi.listEventsPage(runId, options);
-	}
-	async listRuns(options) {
-		return this.#inspectionApi.listRuns(options);
-	}
-	async listRunsPage(options) {
-		return this.#inspectionApi.listRunsPage(options);
-	}
-	async countRuns(options) {
-		return this.#inspectionApi.countRuns(options);
+		return await resumeRun(this.#resumeServices, implementation, runId, options);
 	}
 	async getRunSummary(options) {
-		return this.#inspectionApi.getRunSummary(options);
-	}
-	async getRecoverySummary(options) {
-		return this.#inspectionApi.getRecoverySummary(options);
-	}
-	async getTimeline(runId) {
-		return this.#inspectionApi.getTimeline(runId);
-	}
-	async listStepAttempts(runId, options) {
-		return this.#inspectionApi.listStepAttempts(runId, options);
-	}
-	async listStepAttemptsPage(runId, options) {
-		return this.#inspectionApi.listStepAttemptsPage(runId, options);
-	}
-	async countStepAttempts(runId, options) {
-		return this.#inspectionApi.countStepAttempts(runId, options);
-	}
-	async repairStepAttempts(runId) {
-		return this.#inspectionApi.repairStepAttempts(runId);
-	}
-	async repairMessageIdempotencyIndexes(runId) {
-		return this.#inspectionApi.repairMessageIdempotencyIndexes(runId);
-	}
-	async getStepAttemptSummary(runId, options) {
-		return this.#inspectionApi.getStepAttemptSummary(runId, options);
-	}
-	async cleanupRuns(options) {
-		const result = await this.store.cleanupRuns(options);
-		this.#observation.emitCleanupCompleted(result);
-		return result;
-	}
-	async listCleanupMarkers() {
-		return this.store.listCleanupMarkers();
-	}
-	async applyRetentionPolicy(retentionOptions) {
-		const result = await this.store.cleanupRuns(retentionCleanupOptions(retentionOptions, this.#now));
-		this.#observation.emitRetentionApplied(result);
-		return result;
+		return await getWorkflowRunSummary({
+			store: this.store,
+			now: this.#now(),
+			filters: options
+		});
 	}
 	async rerunWorkflow(runId, options) {
-		return rerunWorkflowRun(this.#runService, async (definition, input, startOptions) => await this.startWorkflow(definition, input, startOptions), runId, options);
-	}
-	async rescheduleRun(runId, options) {
-		return rescheduleWorkflowRun(this.#runService, this.#runLifecycle, runId, options);
-	}
-	async releaseStaleRunLease(runId, options) {
-		return releaseStaleWorkflowRunLease(this.#runService, this.#runLifecycle, runId, options);
-	}
-	async retryFailedRun(runId, options) {
-		return retryFailedWorkflowRun(this.#runService, this.#runLifecycle, runId, options);
-	}
-	async markRunPermanentlyFailed(runId, options) {
-		return markWorkflowRunPermanentlyFailed(this.#runService, this.#runLifecycle, runId, options);
-	}
-	async updateRunMetadata(runId, metadata) {
-		return updateWorkflowRunMetadata(this.#runService, this.#runLifecycle, runId, metadata);
-	}
-	async setRunAttributes(runId, attributes) {
-		return setWorkflowRunAttributes(this.#runService, runId, attributes);
-	}
-	async cancelRun(runId) {
-		return cancelWorkflowRun(this.#runService, this.#runLifecycle, runId);
-	}
-	async resumeHook(token, options) {
-		await resumeHook(token, options, this.#hookService);
-	}
-	async resumeWebhook(token, options) {
-		await resumeWebhook(token, options, this.#hookService);
-	}
-	async disposeHook(token) {
-		return disposeHook(token, this.#hookService);
-	}
-	async disposeWebhook(token) {
-		return disposeWebhook(token, this.#hookService);
-	}
-	async getHookByToken(token) {
-		return getHookByToken(token, this.store, this.#now());
-	}
-	async getStreamInfo(runId, streamIdOrName) {
-		return getStreamInfoForRun(this.#streamService, runId, streamIdOrName);
-	}
-	followStream(runId, streamIdOrName, followOptions) {
-		return followStreamForRun(this.#streamService, runId, streamIdOrName, followOptions);
-	}
-	async waitForStream(runId, streamIdOrName, waitOptions) {
-		return waitForStreamForRun(this.#streamService, runId, streamIdOrName, waitOptions);
-	}
-	async waitForStreamChunk(runId, streamIdOrName, afterIndex, waitOptions) {
-		return waitForStreamChunkForRun(this.#streamService, runId, streamIdOrName, afterIndex, waitOptions);
-	}
-	async waitForStreamTerminal(runId, streamIdOrName, waitOptions) {
-		return waitForStreamTerminalForRun(this.#streamService, runId, streamIdOrName, waitOptions);
-	}
-	async readStream(runId, streamIdOrName, readOptions) {
-		return readStreamForRun(this.#streamService, runId, streamIdOrName, readOptions);
-	}
-	async readStreamPage(runId, streamIdOrName, readOptions) {
-		return readStreamPageForRun(this.#streamService, runId, streamIdOrName, readOptions);
-	}
-	async sendMessage(runId, messageInput, channelOptions) {
-		await sendWorkflowMessageInput(this.#messageService, runId, messageInput, channelOptions);
-	}
-	async broadcastMessage(messageInput, channelOptions) {
-		return broadcastWorkflowMessageInput(this.#messageService, messageInput, channelOptions);
+		return rerunRun(this.context, (definition, input, startOptions) => this.startWorkflow(definition, input, startOptions), runId, options);
 	}
 };
 //#endregion

package/dist/engine/deterministic.d.mts

@@ -1,12 +1,7 @@
-import { StepId } from "../types/step-id.mjs";
-import { WorkflowDeterministicApi, WorkflowStepMetadata } from "../types/step.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { DeterministicApi, StepMetadata } from "../types/step.mjs";
+import { DeterministicValueRecordedEvent } from "../types/events.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/deterministic.d.ts
-declare function createWorkflowDeterministicApi(environment: WorkflowExecutionEnvironment): WorkflowDeterministicApi;
-declare function recordWorkflowDeterministicValue<TValue>(environment: WorkflowExecutionEnvironment, name: string, createValue: (identity: WorkflowStepMetadata) => TValue, checkRecorded?: (recorded: {
-  readonly stepId: StepId;
-  readonly timestamp: Temporal.Instant;
-  readonly value: unknown;
-}) => void): Promise<TValue>;
-//#endregion
-export { createWorkflowDeterministicApi, recordWorkflowDeterministicValue };
+export declare function createDeterministicApi(environment: ExecutionEnvironment): DeterministicApi;
+export declare function recordDeterministicValue<TValue>(environment: ExecutionEnvironment, name: string, createValue: (identity: StepMetadata) => TValue, readRecorded: (recorded: DeterministicValueRecordedEvent) => NoInfer<TValue>): Promise<TValue>;
+//#endregion

package/dist/engine/deterministic.mjs

@@ -1,102 +1,81 @@
+import { WorkflowErrorCode } from "../errors/codes.mjs";
 import { WorkflowOptionsError } from "../errors/base.mjs";
 import { WorkflowReplayDivergenceError } from "../errors/failures.mjs";
-import { isNonNegativeSafeInteger } from "../utility.mjs";
 import "../errors/mod.mjs";
+import { isNonNegativeSafeInteger } from "../values.mjs";
 import { toPersistedValue } from "./serialization.mjs";
-import { appendEventIfCurrentExecution } from "./state.mjs";
-import { resolveWorkflowCommandIdentity } from "./command-identity.mjs";
+import { resolveCommandIdentity } from "./command-identity.mjs";
+import { appendDurableEvent } from "./durable-command.mjs";
+import { isNumber, isString } from "@temelj/value";
 //#region src/engine/deterministic.ts
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
-function createWorkflowDeterministicApi(environment) {
-	const { now, runId } = environment;
+function createDeterministicApi(environment) {
+	const { runId } = environment;
+	/** Records a generated value, checking it both when it is created and when it is replayed. */
+	const checked = async (commandId, expected, isValid, create) => await recordDeterministicValue(environment, commandId, (identity) => {
+		const value = create({
+			runId,
+			commandId: identity.id,
+			commandName: identity.name,
+			commandCount: identity.count
+		});
+		if (!isValid(value)) invalidDeterministicValue(identity.id, expected);
+		return value;
+	}, (recorded) => {
+		if (!isValid(recorded.value)) invalidDeterministicValue(recorded.stepId, expected);
+		return recorded.value;
+	});
 	const api = {
-		async now(commandId = "now") {
-			return await recordWorkflowDeterministicValue(environment, commandId, () => now());
-		},
-		async random(commandId = "random") {
-			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
-				const value = environment.createDeterministicRandom(deterministicValueContext(runId, identity));
-				if (!isDeterministicRandomValue(value)) invalidDeterministicValue(identity.id, "a finite number in [0, 1)");
-				return value;
-			}, (recorded) => {
-				if (!isDeterministicRandomValue(recorded.value)) invalidDeterministicValue(recorded.stepId, "a finite number in [0, 1)");
-			});
-		},
-		async recordedId(commandId = "recorded-id") {
-			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => environment.createRecordedId(deterministicValueContext(runId, identity)));
-		},
-		async id(commandId = "id") {
-			return await api.recordedId(commandId);
-		},
-		async uuid(commandId = "uuid") {
-			return await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
-				const value = environment.createDeterministicUuid(deterministicValueContext(runId, identity));
-				if (!isDeterministicUuidValue(value)) invalidDeterministicValue(identity.id, "a UUID string");
-				return value;
-			}, (recorded) => {
-				if (!isDeterministicUuidValue(recorded.value)) invalidDeterministicValue(recorded.stepId, "a UUID string");
-			});
-		},
+		now: async (commandId = "now") => await checked(commandId, "a Temporal.Instant", isInstant, () => environment.now()),
+		random: async (commandId = "random") => await checked(commandId, "a finite number in [0, 1)", isDeterministicRandomValue, environment.createDeterministicRandom),
+		recordedId: async (commandId = "recorded-id") => await checked(commandId, "a recorded ID string", isString, environment.createRecordedId),
+		id: async (commandId = "id") => await api.recordedId(commandId),
+		uuid: async (commandId = "uuid") => await checked(commandId, "a UUID string", isDeterministicUuidValue, environment.createDeterministicUuid),
 		async bytes(commandId, length) {
-			if (typeof commandId !== "string") WorkflowOptionsError.string("Workflow deterministic bytes commandId");
-			if (commandId.trim() === "") WorkflowOptionsError.nonBlank("Workflow deterministic bytes commandId");
-			if (!isNonNegativeSafeInteger(length)) WorkflowOptionsError.nonNegativeSafeInteger("Workflow deterministic bytes length");
-			const bytes = await recordWorkflowDeterministicValue(environment, commandId, (identity) => {
-				const value = environment.createDeterministicBytes({
-					...deterministicValueContext(runId, identity),
-					length
-				});
-				if (!isDeterministicBytesValue(value, length)) invalidDeterministicValue(identity.id, `a Uint8Array with length ${length}`);
-				return new Uint8Array(value);
-			}, (recorded) => {
-				if (!isDeterministicBytesValue(recorded.value, length)) invalidDeterministicValue(recorded.stepId, `a Uint8Array with length ${length}`);
+			if (commandId.trim() === "") throw new WorkflowOptionsError("Workflow deterministic bytes commandId must not be blank", {
+				code: WorkflowErrorCode.OPTIONS_EXPECTED_NON_BLANK,
+				details: { label: "Workflow deterministic bytes commandId" }
 			});
+			if (!isNonNegativeSafeInteger(length)) WorkflowOptionsError.nonNegativeSafeInteger("Workflow deterministic bytes length");
+			const bytes = await checked(commandId, `a Uint8Array with length ${length}`, (value) => isDeterministicBytesValue(value, length), (context) => environment.createDeterministicBytes({
+				...context,
+				length
+			}));
 			return new Uint8Array(bytes);
 		}
 	};
 	return api;
 }
-async function recordWorkflowDeterministicValue(environment, name, createValue, checkRecorded) {
-	const { store, history, now, limits, executionOwner, runId } = environment;
-	const identity = resolveWorkflowCommandIdentity(history, "deterministic", name);
+function isInstant(value) {
+	return value instanceof Temporal.Instant;
+}
+async function recordDeterministicValue(environment, name, createValue, readRecorded) {
+	const { history, now, limits } = environment;
+	const identity = resolveCommandIdentity(history, "deterministic", name);
 	const recorded = history.deterministicValue(identity.id);
-	if (recorded !== void 0) {
-		checkRecorded?.(recorded);
-		return recorded.value;
-	}
+	if (recorded !== void 0) return readRecorded(recorded);
 	const value = createValue(identity);
-	await appendEventIfCurrentExecution(store, history, {
+	await appendDurableEvent(environment, {
 		kind: "deterministic_value_recorded",
 		timestamp: now(),
 		stepId: identity.id,
 		stepName: identity.name,
 		count: identity.count,
 		value: toPersistedValue(value, "deterministic value", limits)
-	}, executionOwner, limits, void 0, (event, events) => environment.observeDurableEventAppended?.(runId, event, events));
+	});
 	return value;
 }
-function deterministicValueContext(runId, identity) {
-	return {
-		runId,
-		commandId: identity.id,
-		commandName: identity.name,
-		commandCount: identity.count
-	};
-}
 function isDeterministicRandomValue(value) {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 && value < 1;
+	return isNumber(value) && Number.isFinite(value) && value >= 0 && value < 1;
 }
 function isDeterministicUuidValue(value) {
-	return typeof value === "string" && UUID_PATTERN.test(value);
+	return isString(value) && UUID_PATTERN.test(value);
 }
 function isDeterministicBytesValue(value, length) {
 	return value instanceof Uint8Array && value.byteLength === length;
 }
 function invalidDeterministicValue(stepId, expected) {
-	WorkflowReplayDivergenceError.diverged(`recorded deterministic value for ${stepId} must be ${expected}`, {
-		expectedStepId: stepId,
-		actualStepId: stepId
-	});
+	WorkflowReplayDivergenceError.atStep(stepId, `recorded deterministic value for ${stepId} must be ${expected}`);
 }
 //#endregion
-export { createWorkflowDeterministicApi, recordWorkflowDeterministicValue };
+export { createDeterministicApi, recordDeterministicValue };

package/dist/engine/durable-command.d.mts

@@ -1,10 +1,10 @@
 import { EventRecord } from "../types/events.mjs";
-import { WorkflowExecutionEnvironment } from "../types/engine.mjs";
+import { ExecutionEnvironment } from "../types/engine.mjs";
 //#region src/engine/durable-command.d.ts
-type WorkflowDurableStepStartedEvent = Extract<EventRecord, {
+type DurableStepStartedEvent = Extract<EventRecord, {
   readonly kind: "step_started" | "sleep_started" | "child_workflow_started" | "message_send_started" | "message_wait_started" | "stream_started";
 }>;
-declare function appendDurableStepStartedEvent(environment: WorkflowExecutionEnvironment, event: WorkflowDurableStepStartedEvent): Promise<void>;
-declare function appendDurableStepTerminalEvent(environment: WorkflowExecutionEnvironment, event: EventRecord): Promise<void>;
+export declare function appendDurableStepStartedEvent(environment: ExecutionEnvironment, event: DurableStepStartedEvent): Promise<void>;
+export declare function appendDurableEvent(environment: ExecutionEnvironment, event: EventRecord): Promise<void>;
 //#endregion
-export { appendDurableStepStartedEvent, appendDurableStepTerminalEvent };
+export {};

package/dist/engine/durable-command.mjs

@@ -4,7 +4,7 @@ import { appendEventIfCurrentExecution } from "./state.mjs";
 async function appendDurableStepStartedEvent(environment, event) {
 	await appendDurableStepEvent(environment, event, { enforceAttemptBudget: true });
 }
-async function appendDurableStepTerminalEvent(environment, event) {
+async function appendDurableEvent(environment, event) {
 	await appendDurableStepEvent(environment, event);
 }
 async function appendDurableStepEvent(environment, event, options = {}) {
@@ -14,4 +14,4 @@ async function appendDurableStepEvent(environment, event, options = {}) {
 	} : void 0, (appendedEvent, events) => environment.observeDurableEventAppended?.(runId, appendedEvent, events));
 }
 //#endregion
-export { appendDurableStepStartedEvent, appendDurableStepTerminalEvent };
+export { appendDurableEvent, appendDurableStepStartedEvent };