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

package/dist/runtime.mjs

@@ -1,198 +0,0 @@
-import { WorkflowStateError } from "./errors/base.mjs";
-import { WorkflowResultTimeoutError, WorkflowRunCanceledError, WorkflowRunNotFoundError } from "./errors/run.mjs";
-import { durationTotal } from "./utility.mjs";
-import { WorkflowDefinitionError } from "./errors/definition.mjs";
-import { WorkflowRuntimeError } from "./errors/runtime.mjs";
-import "./errors/mod.mjs";
-import { getCompiledWorkflowDefinition } from "./compiled-function.mjs";
-import { Registry } from "./registry.mjs";
-import { createWorkflowBundleRegistry } from "./bundle.mjs";
-import { workflowErrorFromRecord } from "./errors/records.mjs";
-import { durationBetween } from "./temporal.mjs";
-import { nonNegativeTimerDelay, sleep } from "./timer.mjs";
-import { createWorkflowClient } from "./client/create.mjs";
-import { parseWorkflowRuntime } from "./types/runtime.mjs";
-import "temporal-polyfill/global";
-//#region src/runtime.ts
-const DEFAULT_RESULT_POLL_INTERVAL = Temporal.Duration.from({ milliseconds: 100 });
-const WORKFLOW_RUNTIME_CLOCKS = /* @__PURE__ */ new WeakMap();
-const WORKFLOW_RUNTIME_CLIENTS = /* @__PURE__ */ new WeakMap();
-const WORKFLOW_RUNTIME_REGISTRIES = /* @__PURE__ */ new WeakMap();
-/** Creates a workflow runtime backed by a workflow client. */
-function createWorkflowRuntime(options = {}) {
-	return new WorkflowRuntime(options);
-}
-/** Workflow runtime implementation backed by a workflow client. */
-var WorkflowRuntime = class {
-	runs;
-	schedules;
-	locks;
-	workers;
-	#client;
-	#registry;
-	constructor(options = {}) {
-		const { registry, workflows, ...runtimeOptions } = options;
-		if (registry !== void 0 && workflows !== void 0) throw new TypeError("Workflow runtime options cannot include both registry and workflows");
-		const now = options.now ?? Temporal.Now.instant;
-		this.#registry = registry ?? (workflows === void 0 ? new Registry() : createWorkflowBundleRegistry(workflows));
-		this.#client = createWorkflowClient({
-			...runtimeOptions,
-			registry: this.#registry,
-			now
-		});
-		this.runs = {
-			getHandle: async (runId) => await getWorkflowRuntimeRun(this, runId),
-			list: async (options) => await this.#client.runs.list(options)
-		};
-		this.schedules = this.#client.schedules;
-		this.locks = this.#client.locks;
-		this.workers = this.#client.workers;
-		WORKFLOW_RUNTIME_CLOCKS.set(this, now);
-		WORKFLOW_RUNTIME_CLIENTS.set(this, this.#client);
-		WORKFLOW_RUNTIME_REGISTRIES.set(this, this.#registry);
-	}
-	async close() {
-		await this.#client.close();
-	}
-	implementWorkflow(definition, handler) {
-		return this.#registry.implementWorkflow(definition, handler);
-	}
-	register(implementation) {
-		this.#registry.register(implementation);
-	}
-	async start(workflow, ...args) {
-		return await startWorkflowRuntimeRunUnknown(this, workflow, ...args);
-	}
-};
-/** Starts a workflow through an explicit runtime and returns a client run handle. */
-async function startWorkflowRuntimeRun(runtime, workflow, ...args) {
-	return await startWorkflowRuntimeRunUnknown(runtime, workflow, ...args);
-}
-async function startWorkflowRuntimeRunUnknown(runtime, workflow, ...args) {
-	parseWorkflowRuntime(runtime);
-	const client = getWorkflowRuntimeClient(runtime);
-	const registry = getWorkflowRuntimeRegistry(runtime);
-	if (typeof workflow === "function") {
-		const definition = getCompiledWorkflowDefinition(workflow);
-		if (definition === void 0) WorkflowDefinitionError.compiledMetadataMissing();
-		ensureWorkflowRegistered(registry, definition);
-		return await client.runs.start(definition.definition, args);
-	}
-	const target = workflow;
-	if (target.kind === "implementation") {
-		ensureWorkflowRegistered(registry, target);
-		return await client.runs.start(target.definition, args[0], args[1]);
-	}
-	return await client.runs.start(target, args[0], args[1]);
-}
-/** Returns a typed handle for an existing run through an explicit runtime. */
-async function getWorkflowRuntimeRun(runtime, runId) {
-	parseWorkflowRuntime(runtime);
-	const run = await getWorkflowRuntimeClient(runtime).runs.get(runId);
-	if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
-	return createStoredRunHandle(runtime, run);
-}
-function createStoredRunHandle(runtime, initialRun) {
-	const runId = initialRun.id;
-	const now = WORKFLOW_RUNTIME_CLOCKS.get(runtime) ?? Temporal.Now.instant;
-	const client = getWorkflowRuntimeClient(runtime);
-	const getRun = async () => {
-		const run = await client.runs.get(runId);
-		if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
-		return run;
-	};
-	return {
-		runId,
-		workflowName: initialRun.workflowName,
-		...initialRun.workflowVersion === void 0 ? {} : { workflowVersion: initialRun.workflowVersion },
-		getRun,
-		async status() {
-			return (await getRun()).status;
-		},
-		async events() {
-			return await client.runs.events(runId);
-		},
-		async timeline() {
-			return await client.runs.timeline(runId);
-		},
-		async result(options) {
-			const pollInterval = nonNegativeTimerDelay(options?.pollInterval ?? DEFAULT_RESULT_POLL_INTERVAL, "Workflow result pollInterval").clampedDelay;
-			const timeout = options?.timeout;
-			const deadlineAt = timeout === void 0 ? void 0 : now().add(timeout);
-			while (true) {
-				const run = await client.runs.get(runId);
-				if (run === void 0) WorkflowRunNotFoundError.notFound(runId);
-				if (run.status === "completed") return run.output;
-				if (run.status === "failed") {
-					if (run.error === void 0) WorkflowStateError.failedRunMissingError(runId);
-					throw workflowErrorFromRecord(run.error);
-				}
-				if (run.status === "canceled") WorkflowRunCanceledError.canceled(runId);
-				let sleepDelay = pollInterval;
-				if (timeout !== void 0 && deadlineAt !== void 0) {
-					const remainingDelay = durationTotal(durationBetween(now(), deadlineAt));
-					if (remainingDelay <= 0) WorkflowResultTimeoutError.timedOut(runId, timeout);
-					sleepDelay = Math.min(sleepDelay, remainingDelay);
-				}
-				await sleep(sleepDelay);
-			}
-		},
-		async getStreamInfo(streamIdOrName) {
-			return await client.streams.getInfo(runId, streamIdOrName);
-		},
-		followStream(streamIdOrName, options) {
-			return client.streams.follow(runId, streamIdOrName, options);
-		},
-		async waitForStream(streamIdOrName, options) {
-			return await client.streams.wait(runId, streamIdOrName, options);
-		},
-		async waitForStreamChunk(streamIdOrName, afterIndex, options) {
-			return await client.streams.waitForChunk(runId, streamIdOrName, afterIndex, options);
-		},
-		async waitForStreamTerminal(streamIdOrName, options) {
-			return await client.streams.waitForTerminal(runId, streamIdOrName, options);
-		},
-		async readStream(streamIdOrName, options) {
-			return await client.streams.read(runId, streamIdOrName, options);
-		},
-		async readStreamPage(streamIdOrName, options) {
-			return await client.streams.readPage(runId, streamIdOrName, options);
-		},
-		async reschedule(options) {
-			return await client.admin.reschedule(runId, options);
-		},
-		async releaseStaleLease(options) {
-			return await client.admin.releaseStaleLease(runId, options);
-		},
-		async retryFailed(options) {
-			return await client.admin.retryFailed(runId, options);
-		},
-		async markPermanentlyFailed(options) {
-			return await client.admin.markPermanentlyFailed(runId, options);
-		},
-		async setMetadata(metadata) {
-			return await client.admin.updateMetadata(runId, metadata);
-		},
-		async setAttributes(attributes) {
-			return await client.admin.setAttributes(runId, attributes);
-		},
-		async cancel() {
-			return await client.admin.cancel(runId);
-		}
-	};
-}
-function getWorkflowRuntimeClient(runtime) {
-	const client = WORKFLOW_RUNTIME_CLIENTS.get(runtime);
-	if (client === void 0) WorkflowRuntimeError.clientMissing();
-	return client;
-}
-function getWorkflowRuntimeRegistry(runtime) {
-	const registry = WORKFLOW_RUNTIME_REGISTRIES.get(runtime);
-	if (registry === void 0) WorkflowRuntimeError.registryMissing();
-	return registry;
-}
-function ensureWorkflowRegistered(registry, implementation) {
-	if (registry.get(implementation.definition) === void 0) registry.register(implementation);
-}
-//#endregion
-export { WorkflowRuntime, createWorkflowRuntime, getWorkflowRuntimeRun, startWorkflowRuntimeRun };

package/dist/store/append-projection.d.mts

@@ -1,15 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowStorage } from "../types/store.mjs";
-import { WorkflowEventAppendAtomicProjectionPlanner, WorkflowEventAppendSuccessOutcome } from "./event-append.mjs";
-//#region src/store/append-projection.d.ts
-interface WorkflowAppendProjectionPipeline {
-  readonly materializesAtomically: boolean;
-  readonly planAtomicProjections?: WorkflowEventAppendAtomicProjectionPlanner;
-  finalize(outcome: WorkflowEventAppendSuccessOutcome): Promise<readonly EventRecord[]>;
-  finalizePostCommit(outcome: WorkflowEventAppendSuccessOutcome): Promise<void>;
-}
-declare function createWorkflowAppendProjectionPipeline(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord): Promise<WorkflowAppendProjectionPipeline>;
-//#endregion
-export { WorkflowAppendProjectionPipeline, createWorkflowAppendProjectionPipeline };

package/dist/store/append-projection.mjs

@@ -1,26 +0,0 @@
-import { supportsWorkflowAtomicBatchWrite } from "./capabilities.mjs";
-import { createWorkflowStepAttemptMaterializationStoragePlan, materializeStepAttemptForAppendOutcome } from "./materialization.mjs";
-import { projectMessageIdempotencyIndexForAppendOutcome } from "./message-index.mjs";
-//#region src/store/append-projection.ts
-async function createWorkflowAppendProjectionPipeline(storage, namespace, runId, event) {
-	if (!supportsWorkflowAtomicBatchWrite(storage)) return createWorkflowAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, void 0);
-	return createWorkflowAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, await createWorkflowStepAttemptMaterializationStoragePlan(storage, namespace, runId, event));
-}
-function createWorkflowAppendProjectionPipelineFromStepAttemptPlan(storage, namespace, runId, event, initialStepAttemptPlan) {
-	return {
-		materializesAtomically: initialStepAttemptPlan?.materializes === true,
-		planAtomicProjections: createWorkflowAppendAtomicProjectionPlanner(storage, namespace, runId, event, initialStepAttemptPlan),
-		async finalize(outcome) {
-			return await projectMessageIdempotencyIndexForAppendOutcome(storage, namespace, runId, event, outcome);
-		},
-		async finalizePostCommit(outcome) {
-			if (!supportsWorkflowAtomicBatchWrite(storage)) await materializeStepAttemptForAppendOutcome(storage, namespace, runId, event, outcome);
-		}
-	};
-}
-function createWorkflowAppendAtomicProjectionPlanner(storage, namespace, runId, event, initialStepAttemptPlan) {
-	if (!supportsWorkflowAtomicBatchWrite(storage)) return;
-	return async (attempt) => attempt === 0 && initialStepAttemptPlan !== void 0 ? initialStepAttemptPlan : await createWorkflowStepAttemptMaterializationStoragePlan(storage, namespace, runId, event);
-}
-//#endregion
-export { createWorkflowAppendProjectionPipeline };

package/dist/store/compaction.d.mts

@@ -1,5 +0,0 @@
-//#region src/store/compaction.d.ts
-/** Removes undefined optional fields before persisting a workflow store record. */
-declare function compactWorkflowStoreRecord<TRecord extends object>(record: TRecord): TRecord;
-//#endregion
-export { compactWorkflowStoreRecord };

package/dist/store/compaction.mjs

@@ -1,8 +0,0 @@
-import { omitUndefined } from "../collection.mjs";
-//#region src/store/compaction.ts
-/** Removes undefined optional fields before persisting a workflow store record. */
-function compactWorkflowStoreRecord(record) {
-	return omitUndefined(record);
-}
-//#endregion
-export { compactWorkflowStoreRecord };

package/dist/store/event-append-project.d.mts

@@ -1,15 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowStorage } from "../types/store.mjs";
-import { WorkflowEventAppendOutcome, WorkflowEventAppendSuccessOutcome } from "./event-append.mjs";
-import { WorkflowAppendProjectionPipeline } from "./append-projection.mjs";
-//#region src/store/event-append-project.d.ts
-interface WorkflowEventAppendProjectionOutcome {
-  readonly outcome: WorkflowEventAppendOutcome;
-  readonly projectionPipeline?: WorkflowAppendProjectionPipeline;
-}
-declare function appendEventWithProjections(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, projectionPipeline?: WorkflowAppendProjectionPipeline): Promise<WorkflowEventAppendSuccessOutcome>;
-declare function appendEventWithProjectionPipelineIfRunCurrent(storage: WorkflowStorage, namespace: string, currentRun: WorkflowRunRecord, event: EventRecord): Promise<WorkflowEventAppendProjectionOutcome>;
-//#endregion
-export { WorkflowEventAppendProjectionOutcome, appendEventWithProjectionPipelineIfRunCurrent, appendEventWithProjections };

package/dist/store/event-append-project.mjs

@@ -1,77 +0,0 @@
-import { supportsWorkflowAtomicBatchWrite, supportsWorkflowConditionalWrite } from "./capabilities.mjs";
-import { isStoredWorkflowRunRevisionCurrent, isWorkflowRunStaleForAppend, rollbackAppendedEventIfRunStale } from "./run.mjs";
-import { duplicateMessageAppendOutcome } from "./message-index.mjs";
-import { createWorkflowAppendProjectionPipeline } from "./append-projection.mjs";
-import { appendEventIfCurrent, appendEventIfRunRevisionCurrentAtomically, appendEventWithAtomicProjectionPlan, makeStaleRunAppendOutcome } from "./event-append.mjs";
-//#region src/store/event-append-project.ts
-async function appendEventWithProjections(storage, namespace, runId, event, projectionPipeline) {
-	const appendProjectionPipeline = projectionPipeline ?? await createWorkflowAppendProjectionPipeline(storage, namespace, runId, event);
-	const outcome = await appendEventWithAtomicProjectionPlan(storage, namespace, runId, event, appendProjectionPipeline.planAtomicProjections, duplicateMessageAppendOutcome);
-	await appendProjectionPipeline.finalizePostCommit(outcome);
-	return outcome;
-}
-async function appendEventWithProjectionPipelineIfRunCurrent(storage, namespace, currentRun, event) {
-	const runId = currentRun.id;
-	if (isWorkflowRunStaleForAppend(currentRun, event)) return { outcome: makeStaleRunAppendOutcome() };
-	const projectionPipeline = await createWorkflowAppendProjectionPipeline(storage, namespace, runId, event);
-	if (event.kind === "message_sent" && !supportsWorkflowAtomicBatchWrite(storage)) return await appendMessageEventIfRunCurrent(storage, namespace, currentRun, event, projectionPipeline);
-	if (!supportsWorkflowAtomicBatchWrite(storage) || projectionPipeline.materializesAtomically) return workflowEventAppendProjectionOutcome(await appendEventIfRunRevisionCurrentWithPostAppendGuard(storage, namespace, currentRun, event, projectionPipeline), projectionPipeline);
-	return workflowEventAppendProjectionOutcome(await appendEventIfRunRevisionCurrentAtomically(storage, namespace, currentRun, event, duplicateMessageAppendOutcome), projectionPipeline);
-}
-function workflowEventAppendProjectionOutcome(outcome, projectionPipeline) {
-	if (projectionPipeline === void 0) return { outcome };
-	return {
-		outcome,
-		projectionPipeline
-	};
-}
-async function appendEventIfRunRevisionCurrentWithPostAppendGuard(storage, namespace, currentRun, event, projectionPipeline) {
-	const runId = currentRun.id;
-	if (!await isStoredWorkflowRunRevisionCurrent(storage, namespace, currentRun)) return makeStaleRunAppendOutcome();
-	const outcome = await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline);
-	if (outcome.status !== "appended") return outcome;
-	return await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome);
-}
-async function appendMessageEventIfRunCurrent(storage, namespace, currentRun, event, projectionPipeline) {
-	const runId = currentRun.id;
-	if (!await isStoredWorkflowRunRevisionCurrent(storage, namespace, currentRun)) return { outcome: makeStaleRunAppendOutcome() };
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		const outcome = await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline);
-		if (outcome.status !== "appended") return {
-			outcome,
-			projectionPipeline
-		};
-		return {
-			outcome: await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome),
-			projectionPipeline
-		};
-	}
-	const outcome = await appendEventIfCurrent(storage, namespace, runId, event, { detectDuplicate: duplicateMessageAppendOutcome });
-	if (outcome.status !== "appended") {
-		if (!await isStoredWorkflowRunRevisionCurrent(storage, namespace, currentRun)) return {
-			outcome: makeStaleRunAppendOutcome(),
-			projectionPipeline
-		};
-		return {
-			outcome,
-			projectionPipeline
-		};
-	}
-	if (!await isStoredWorkflowRunRevisionCurrent(storage, namespace, currentRun)) {
-		await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome);
-		return {
-			outcome: makeStaleRunAppendOutcome(),
-			projectionPipeline
-		};
-	}
-	return {
-		outcome: await guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome),
-		projectionPipeline
-	};
-}
-async function guardAppendedEventAgainstStaleRun(storage, namespace, runId, event, outcome) {
-	if (await rollbackAppendedEventIfRunStale(storage, namespace, runId, event, outcome.events)) return makeStaleRunAppendOutcome();
-	return outcome;
-}
-//#endregion
-export { appendEventWithProjectionPipelineIfRunCurrent, appendEventWithProjections };

package/dist/store/event-append.d.mts

@@ -1,37 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowStorage } from "../types/store.mjs";
-import { StorageCompareAndSetManyItem, StorageValue } from "@temelj/storage";
-//#region src/store/event-append.d.ts
-type WorkflowEventAppendSuccessOutcome = {
-  readonly status: "appended";
-  readonly events: readonly EventRecord[];
-  readonly previousEventHistory?: StorageValue;
-} | {
-  readonly status: "duplicate";
-  readonly events: readonly EventRecord[];
-};
-type WorkflowEventAppendOutcome = WorkflowEventAppendSuccessOutcome | {
-  readonly status: "staleRun";
-};
-type WorkflowEventAppendedOutcome = Extract<WorkflowEventAppendSuccessOutcome, {
-  readonly status: "appended";
-}>;
-interface WorkflowEventAppendAtomicProjectionPlan {
-  readonly item?: StorageCompareAndSetManyItem<StorageValue>;
-}
-type WorkflowEventAppendAtomicProjectionPlanner = (attempt: number) => Promise<WorkflowEventAppendAtomicProjectionPlan | undefined>;
-type WorkflowEventAppendDuplicateDetector = (runId: RunId, events: readonly EventRecord[], event: EventRecord) => Extract<WorkflowEventAppendSuccessOutcome, {
-  readonly status: "duplicate";
-}> | undefined;
-interface EventAppendOptions {
-  readonly detectDuplicate?: WorkflowEventAppendDuplicateDetector;
-  readonly previousEventHistory?: StorageValue;
-}
-declare function makeStaleRunAppendOutcome(): WorkflowEventAppendOutcome;
-declare function appendEventWithAtomicProjectionPlan(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, planProjection?: WorkflowEventAppendAtomicProjectionPlanner, detectDuplicate?: WorkflowEventAppendDuplicateDetector): Promise<WorkflowEventAppendSuccessOutcome>;
-declare function appendEventIfRunRevisionCurrentAtomically(storage: WorkflowStorage, namespace: string, currentRun: WorkflowRunRecord, event: EventRecord, detectDuplicate?: WorkflowEventAppendDuplicateDetector): Promise<WorkflowEventAppendOutcome>;
-declare function appendEventIfCurrent(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord, options?: EventAppendOptions): Promise<WorkflowEventAppendSuccessOutcome>;
-//#endregion
-export { WorkflowEventAppendAtomicProjectionPlanner, WorkflowEventAppendDuplicateDetector, WorkflowEventAppendOutcome, WorkflowEventAppendSuccessOutcome, WorkflowEventAppendedOutcome, appendEventIfCurrent, appendEventIfRunRevisionCurrentAtomically, appendEventWithAtomicProjectionPlan, makeStaleRunAppendOutcome };

package/dist/store/event-append.mjs

@@ -1,80 +0,0 @@
-import { WorkflowStateError } from "../errors/base.mjs";
-import "../errors/mod.mjs";
-import { supportsWorkflowAtomicBatchWrite, supportsWorkflowConditionalWrite } from "./capabilities.mjs";
-import { makeEventsKey, makeRunKey } from "../store-keys.mjs";
-import { toStorageValue } from "./storage-value.mjs";
-import { createRunRevisionGuardedEventHistoryCompareAndSetItems, createWorkflowEventHistoryCompareAndSetItem, getStoredEventHistory } from "./event-history.mjs";
-//#region src/store/event-append.ts
-const MAX_APPEND_EVENT_ATTEMPTS = 16;
-function makeAppendedEventOutcome(events, previousEventHistory) {
-	return {
-		status: "appended",
-		events,
-		...previousEventHistory === void 0 ? {} : { previousEventHistory }
-	};
-}
-function makeStaleRunAppendOutcome() {
-	return { status: "staleRun" };
-}
-async function appendEventWithAtomicProjectionPlan(storage, namespace, runId, event, planProjection, detectDuplicate) {
-	if (!supportsWorkflowAtomicBatchWrite(storage)) return await appendEventIfCurrent(storage, namespace, runId, event, {
-		detectDuplicate,
-		previousEventHistory: await storage.get(makeEventsKey(namespace, runId))
-	});
-	const eventsStorageKey = makeEventsKey(namespace, runId);
-	for (let attempt = 0; attempt < MAX_APPEND_EVENT_ATTEMPTS; attempt++) {
-		const appendState = await readWorkflowEventAppendState(storage, eventsStorageKey, runId, event, detectDuplicate);
-		const duplicate = appendState.duplicate;
-		if (duplicate !== void 0) return duplicate;
-		const projectionPlan = await planProjection?.(attempt);
-		const items = [createWorkflowEventHistoryCompareAndSetItem(eventsStorageKey, appendState.raw, appendState.nextEvents), ...projectionPlan?.item === void 0 ? [] : [projectionPlan.item]];
-		if (await storage.compareAndSetMany(items)) return makeAppendedEventOutcome(appendState.nextEvents, appendState.raw);
-	}
-	WorkflowStateError.failedWorkflowEventAppend(runId, MAX_APPEND_EVENT_ATTEMPTS);
-}
-async function appendEventIfRunRevisionCurrentAtomically(storage, namespace, currentRun, event, detectDuplicate) {
-	const runId = currentRun.id;
-	const runStorageKey = makeRunKey(namespace, runId);
-	const eventsStorageKey = makeEventsKey(namespace, runId);
-	for (let attempt = 0; attempt < MAX_APPEND_EVENT_ATTEMPTS; attempt++) {
-		const appendState = await readWorkflowEventAppendState(storage, eventsStorageKey, runId, event, detectDuplicate);
-		const duplicate = appendState.duplicate;
-		if (duplicate !== void 0) {
-			if (await storage.compareAndSetMany(createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, appendState.raw, appendState.currentEvents))) return duplicate;
-			continue;
-		}
-		if (await storage.compareAndSetMany(createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, appendState.raw, appendState.nextEvents))) return makeAppendedEventOutcome(appendState.nextEvents, appendState.raw);
-		if (event.kind === "message_sent") return makeStaleRunAppendOutcome();
-	}
-	return makeStaleRunAppendOutcome();
-}
-async function appendEventIfCurrent(storage, namespace, runId, event, options = {}) {
-	const key = makeEventsKey(namespace, runId);
-	if (!supportsWorkflowConditionalWrite(storage)) {
-		const current = (await getStoredEventHistory(storage, key)).events;
-		const duplicate = options.detectDuplicate?.(runId, current, event);
-		if (duplicate !== void 0) return duplicate;
-		const events = [...current, event];
-		await storage.set(key, toStorageValue(events));
-		return makeAppendedEventOutcome(events, options.previousEventHistory);
-	}
-	for (let attempt = 0; attempt < MAX_APPEND_EVENT_ATTEMPTS; attempt++) {
-		const appendState = await readWorkflowEventAppendState(storage, key, runId, event, options.detectDuplicate);
-		const duplicate = appendState.duplicate;
-		if (duplicate !== void 0) return duplicate;
-		if (await storage.compareAndSet(key, appendState.raw, toStorageValue(appendState.nextEvents))) return makeAppendedEventOutcome(appendState.nextEvents, appendState.raw);
-	}
-	WorkflowStateError.failedWorkflowEventAppend(runId, MAX_APPEND_EVENT_ATTEMPTS);
-}
-async function readWorkflowEventAppendState(storage, eventsStorageKey, runId, event, detectDuplicate) {
-	const { raw, events: currentEvents } = await getStoredEventHistory(storage, eventsStorageKey);
-	const duplicate = detectDuplicate?.(runId, currentEvents, event);
-	return {
-		raw,
-		currentEvents,
-		...duplicate === void 0 ? {} : { duplicate },
-		nextEvents: duplicate === void 0 ? [...currentEvents, event] : currentEvents
-	};
-}
-//#endregion
-export { appendEventIfCurrent, appendEventIfRunRevisionCurrentAtomically, appendEventWithAtomicProjectionPlan, makeStaleRunAppendOutcome };

package/dist/store/event-history.d.mts

@@ -1,22 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowStorage } from "../types/store.mjs";
-import { StorageCompareAndSetManyItem, StorageValue } from "@temelj/storage";
-//#region src/store/event-history.d.ts
-type WorkflowEventHistoryCompareAndSetItem = StorageCompareAndSetManyItem<StorageValue>;
-type WorkflowRunRevisionCompareAndSetItem = StorageCompareAndSetManyItem<StorageValue>;
-declare function getStoredEventHistory(storage: WorkflowStorage, key: string): Promise<{
-  readonly raw: StorageValue | undefined;
-  readonly events: readonly EventRecord[];
-}>;
-declare function getStoredCleanupEventHistory(storage: WorkflowStorage, key: string): Promise<{
-  readonly raw: StorageValue | undefined;
-  readonly events: readonly EventRecord[];
-}>;
-declare function isSameWorkflowEventIdentity(left: EventRecord, right: EventRecord): boolean;
-declare function rollbackAppendedEventIfCurrent(storage: WorkflowStorage, namespace: string, runId: RunId, expectedEvents: readonly EventRecord[], previousEventHistory?: StorageValue): Promise<boolean>;
-declare function createWorkflowEventHistoryCompareAndSetItem(eventsStorageKey: string, expected: StorageValue | undefined, events: readonly EventRecord[]): WorkflowEventHistoryCompareAndSetItem;
-declare function createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey: string, currentRun: WorkflowRunRecord, eventsStorageKey: string, expectedEvents: StorageValue | undefined, events: readonly EventRecord[]): readonly [WorkflowRunRevisionCompareAndSetItem, WorkflowEventHistoryCompareAndSetItem];
-//#endregion
-export { createRunRevisionGuardedEventHistoryCompareAndSetItems, createWorkflowEventHistoryCompareAndSetItem, getStoredCleanupEventHistory, getStoredEventHistory, isSameWorkflowEventIdentity, rollbackAppendedEventIfCurrent };

package/dist/store/event-history.mjs

@@ -1,75 +0,0 @@
-import { getEventDescriptor, isCleanupEventRecord } from "../events/descriptors.mjs";
-import { supportsWorkflowConditionalWrite } from "./capabilities.mjs";
-import { makeEventsKey } from "../store-keys.mjs";
-import { isSameWorkflowStorageValue } from "./revision.mjs";
-import { toStorageValue } from "./storage-value.mjs";
-import { isReadableEventRecord } from "./validation.mjs";
-//#region src/store/event-history.ts
-async function getStoredEventHistory(storage, key) {
-	const raw = await storage.get(key);
-	return {
-		raw,
-		events: Array.isArray(raw) ? raw.filter(isReadableEventRecord) : []
-	};
-}
-async function getStoredCleanupEventHistory(storage, key) {
-	const history = await getStoredEventHistory(storage, key);
-	return {
-		raw: history.raw,
-		events: history.events.filter(isCleanupEventRecord)
-	};
-}
-function isSameWorkflowEventIdentity(left, right) {
-	if (left.kind !== right.kind || Temporal.Instant.compare(left.timestamp, right.timestamp) !== 0) return false;
-	const descriptor = getEventDescriptor(left.kind);
-	return isSameWorkflowEventFields(left, right, descriptor.identityFields) && isSameWorkflowEventValueFields(left, right, descriptor.valueIdentityFields) && isSameWorkflowEventStringListFields(left, right, descriptor.stringListIdentityFields);
-}
-function isSameWorkflowEventFields(left, right, fields = []) {
-	return fields.every((field) => Reflect.get(left, field) === Reflect.get(right, field));
-}
-function isSameWorkflowEventValueFields(left, right, fields = []) {
-	return fields.every((field) => isSameWorkflowStorageValue(Reflect.get(left, field), Reflect.get(right, field)));
-}
-function isSameWorkflowEventStringListFields(left, right, fields = []) {
-	return fields.every((field) => {
-		const leftValue = Reflect.get(left, field);
-		const rightValue = Reflect.get(right, field);
-		const leftValues = Array.isArray(leftValue) && leftValue.every((item) => typeof item === "string" && item.trim() !== "") ? leftValue : void 0;
-		const rightValues = Array.isArray(rightValue) && rightValue.every((item) => typeof item === "string" && item.trim() !== "") ? rightValue : void 0;
-		if (leftValues === void 0 || rightValues === void 0) return leftValues === rightValues;
-		if (leftValues.length !== rightValues.length) return false;
-		return leftValues.every((value, index) => value === rightValues[index]);
-	});
-}
-async function rollbackAppendedEventIfCurrent(storage, namespace, runId, expectedEvents, previousEventHistory) {
-	if (expectedEvents.length === 0) return false;
-	const key = makeEventsKey(namespace, runId);
-	const rolledBackEvents = expectedEvents.slice(0, -1);
-	if (supportsWorkflowConditionalWrite(storage)) return await storage.compareAndSet(key, toStorageValue(expectedEvents), previousEventHistory ?? toStorageValue(rolledBackEvents));
-	const current = (await getStoredEventHistory(storage, key)).events;
-	const expectedLast = expectedEvents.at(-1);
-	const currentLast = current.at(-1);
-	if (current.length !== expectedEvents.length || expectedLast === void 0 || currentLast === void 0 || !isSameWorkflowEventIdentity(currentLast, expectedLast)) return false;
-	await storage.set(key, previousEventHistory ?? toStorageValue(rolledBackEvents));
-	return true;
-}
-function createWorkflowEventHistoryCompareAndSetItem(eventsStorageKey, expected, events) {
-	return {
-		key: eventsStorageKey,
-		expected,
-		value: toStorageValue(events)
-	};
-}
-function createWorkflowRunRevisionCompareAndSetItem(runStorageKey, currentRun) {
-	const value = toStorageValue(currentRun);
-	return {
-		key: runStorageKey,
-		expected: value,
-		value
-	};
-}
-function createRunRevisionGuardedEventHistoryCompareAndSetItems(runStorageKey, currentRun, eventsStorageKey, expectedEvents, events) {
-	return [createWorkflowRunRevisionCompareAndSetItem(runStorageKey, currentRun), createWorkflowEventHistoryCompareAndSetItem(eventsStorageKey, expectedEvents, events)];
-}
-//#endregion
-export { createRunRevisionGuardedEventHistoryCompareAndSetItems, createWorkflowEventHistoryCompareAndSetItem, getStoredCleanupEventHistory, getStoredEventHistory, isSameWorkflowEventIdentity, rollbackAppendedEventIfCurrent };

package/dist/store/event.d.mts

@@ -1,10 +0,0 @@
-import { RunId } from "../types/run-id.mjs";
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { EventRecord } from "../types/events.mjs";
-import { WorkflowStorage } from "../types/store.mjs";
-//#region src/store/event.d.ts
-declare function appendWorkflowEvent(storage: WorkflowStorage, namespace: string, runId: RunId, event: EventRecord): Promise<readonly EventRecord[]>;
-declare function appendWorkflowEventIfRunCurrent(storage: WorkflowStorage, namespace: string, current: WorkflowRunRecord, event: EventRecord): Promise<readonly EventRecord[] | undefined>;
-declare function getWorkflowEvents(storage: WorkflowStorage, namespace: string, runId: RunId): Promise<readonly EventRecord[]>;
-//#endregion
-export { appendWorkflowEvent, appendWorkflowEventIfRunCurrent, getWorkflowEvents };

package/dist/store/event.mjs

@@ -1,28 +0,0 @@
-import { WorkflowStateError } from "../errors/base.mjs";
-import { makeEventsKey } from "../store-keys.mjs";
-import { requireReadableStoreRun } from "./validation.mjs";
-import { getStoredEventHistory } from "./event-history.mjs";
-import { requireReadableStoredWorkflowRun } from "./run.mjs";
-import { createWorkflowAppendProjectionPipeline } from "./append-projection.mjs";
-import { appendEventWithProjectionPipelineIfRunCurrent, appendEventWithProjections } from "./event-append-project.mjs";
-//#region src/store/event.ts
-async function finalizeWorkflowAppendOutcome(outcome, projectionPipeline) {
-	if (outcome.status === "staleRun") return;
-	if (projectionPipeline === void 0) WorkflowStateError.appendProjectionPipelineMissing();
-	return await projectionPipeline.finalize(outcome);
-}
-async function appendWorkflowEvent(storage, namespace, runId, event) {
-	await requireReadableStoredWorkflowRun(storage, namespace, runId);
-	const projectionPipeline = await createWorkflowAppendProjectionPipeline(storage, namespace, runId, event);
-	return await finalizeWorkflowAppendOutcome(await appendEventWithProjections(storage, namespace, runId, event, projectionPipeline), projectionPipeline);
-}
-async function appendWorkflowEventIfRunCurrent(storage, namespace, current, event) {
-	requireReadableStoreRun(current, namespace);
-	const appendOutcome = await appendEventWithProjectionPipelineIfRunCurrent(storage, namespace, current, event);
-	return await finalizeWorkflowAppendOutcome(appendOutcome.outcome, appendOutcome.projectionPipeline);
-}
-async function getWorkflowEvents(storage, namespace, runId) {
-	return (await getStoredEventHistory(storage, makeEventsKey(namespace, runId))).events;
-}
-//#endregion
-export { appendWorkflowEvent, appendWorkflowEventIfRunCurrent, getWorkflowEvents };

package/dist/store/idempotency.d.mts

@@ -1,10 +0,0 @@
-import { WorkflowRunRecord } from "../types/run.mjs";
-import { WorkflowIdempotencyKeyOptions, WorkflowStorage } from "../types/store.mjs";
-//#region src/store/idempotency.d.ts
-interface WorkflowIdempotencyRunReader {
-  getRun(runId: string): Promise<WorkflowRunRecord | undefined>;
-}
-declare function createRunWithIdempotency(storage: WorkflowStorage, namespace: string, store: WorkflowIdempotencyRunReader, run: WorkflowRunRecord): Promise<WorkflowRunRecord>;
-declare function getRunByIdempotencyKey(storage: WorkflowStorage, namespace: string, store: WorkflowIdempotencyRunReader, options: WorkflowIdempotencyKeyOptions): Promise<WorkflowRunRecord | undefined>;
-//#endregion
-export { createRunWithIdempotency, getRunByIdempotencyKey };