awaitly 1.0.0

package/dist/persistence.d.ts

@@ -0,0 +1,572 @@
+import { R as Result, af as StepFailureMeta } from './core-BuTBsR0x.js';
+import { e as ResumeStateEntry, R as ResumeState, S as StepCache } from './workflow-entry-C6nH8ByN.js';
+
+/**
+ * awaitly/persistence
+ *
+ * Pluggable Persistence Adapters for StepCache and ResumeState.
+ * Provides adapters for Redis, file system, and in-memory storage,
+ * plus helpers for JSON-safe serialization of causes.
+ */
+
+/**
+ * JSON-safe representation of a Result.
+ */
+interface SerializedResult {
+    ok: boolean;
+    value?: unknown;
+    error?: unknown;
+    cause?: SerializedCause;
+}
+/**
+ * JSON-safe representation of a cause value.
+ * Handles Error objects and other non-JSON-safe types.
+ */
+interface SerializedCause {
+    type: "error" | "value" | "undefined";
+    errorName?: string;
+    errorMessage?: string;
+    errorStack?: string;
+    value?: unknown;
+}
+/**
+ * JSON-safe representation of StepFailureMeta.
+ */
+interface SerializedMeta {
+    origin: "result" | "throw";
+    resultCause?: SerializedCause;
+    thrown?: SerializedCause;
+}
+/**
+ * JSON-safe representation of a ResumeStateEntry.
+ */
+interface SerializedEntry {
+    result: SerializedResult;
+    meta?: SerializedMeta;
+}
+/**
+ * JSON-safe representation of ResumeState.
+ */
+interface SerializedState {
+    version: number;
+    entries: Record<string, SerializedEntry>;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Serialize a cause value to a JSON-safe format.
+ */
+declare function serializeCause(cause: unknown): SerializedCause;
+/**
+ * Deserialize a cause value from JSON-safe format.
+ */
+declare function deserializeCause(serialized: SerializedCause): unknown;
+/**
+ * Serialize a Result to a JSON-safe format.
+ */
+declare function serializeResult(result: Result<unknown, unknown, unknown>): SerializedResult;
+/**
+ * Deserialize a Result from JSON-safe format.
+ */
+declare function deserializeResult(serialized: SerializedResult): Result<unknown, unknown, unknown>;
+/**
+ * Serialize StepFailureMeta to a JSON-safe format.
+ */
+declare function serializeMeta(meta: StepFailureMeta): SerializedMeta;
+/**
+ * Deserialize StepFailureMeta from JSON-safe format.
+ */
+declare function deserializeMeta(serialized: SerializedMeta): StepFailureMeta;
+/**
+ * Serialize a ResumeStateEntry to a JSON-safe format.
+ */
+declare function serializeEntry(entry: ResumeStateEntry): SerializedEntry;
+/**
+ * Deserialize a ResumeStateEntry from JSON-safe format.
+ */
+declare function deserializeEntry(serialized: SerializedEntry): ResumeStateEntry;
+/**
+ * Serialize ResumeState to a JSON-safe format.
+ */
+declare function serializeState(state: ResumeState, metadata?: Record<string, unknown>): SerializedState;
+/**
+ * Deserialize ResumeState from JSON-safe format.
+ */
+declare function deserializeState(serialized: SerializedState): ResumeState;
+/**
+ * Convert ResumeState to a JSON string.
+ */
+declare function stringifyState(state: ResumeState, metadata?: Record<string, unknown>): string;
+/**
+ * Parse ResumeState from a JSON string.
+ */
+declare function parseState(json: string): ResumeState;
+/**
+ * Options for the in-memory cache adapter.
+ */
+interface MemoryCacheOptions {
+    /**
+     * Maximum number of entries to store.
+     * Oldest entries are evicted when limit is reached.
+     */
+    maxSize?: number;
+    /**
+     * Time-to-live in milliseconds.
+     * Entries are automatically removed after this duration.
+     */
+    ttl?: number;
+}
+/**
+ * Create an in-memory StepCache with optional LRU eviction and TTL.
+ *
+ * @param options - Cache options
+ * @returns StepCache implementation
+ *
+ * @example
+ * ```typescript
+ * const cache = createMemoryCache({ maxSize: 1000, ttl: 60000 });
+ * const workflow = createWorkflow(deps, { cache });
+ * ```
+ */
+declare function createMemoryCache(options?: MemoryCacheOptions): StepCache;
+/**
+ * Options for the file system cache adapter.
+ */
+interface FileCacheOptions {
+    /**
+     * Directory to store cache files.
+     */
+    directory: string;
+    /**
+     * File extension for cache files.
+     * @default '.json'
+     */
+    extension?: string;
+    /**
+     * Custom file system interface (for testing or custom implementations).
+     */
+    fs?: FileSystemInterface;
+}
+/**
+ * Minimal file system interface for cache operations.
+ */
+interface FileSystemInterface {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, data: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    readdir(path: string): Promise<string[]>;
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+}
+/**
+ * Create a file system-based StepCache.
+ * Each step result is stored as a separate JSON file.
+ *
+ * @param options - Cache options
+ * @returns StepCache implementation (async operations wrapped in sync interface)
+ *
+ * @example
+ * ```typescript
+ * import * as fs from 'fs/promises';
+ *
+ * const cache = createFileCache({
+ *   directory: './workflow-cache',
+ *   fs: {
+ *     readFile: (path) => fs.readFile(path, 'utf-8'),
+ *     writeFile: (path, data) => fs.writeFile(path, data, 'utf-8'),
+ *     unlink: fs.unlink,
+ *     exists: async (path) => fs.access(path).then(() => true).catch(() => false),
+ *     readdir: fs.readdir,
+ *     mkdir: fs.mkdir,
+ *   },
+ * });
+ * ```
+ */
+declare function createFileCache(options: FileCacheOptions): StepCache & {
+    /** Initialize the cache directory. Call before using the cache. */
+    init(): Promise<void>;
+    /** Get a result asynchronously. */
+    getAsync(key: string): Promise<Result<unknown, unknown, unknown> | undefined>;
+    /** Set a result asynchronously. */
+    setAsync(key: string, result: Result<unknown, unknown, unknown>): Promise<void>;
+    /** Delete a result asynchronously. */
+    deleteAsync(key: string): Promise<boolean>;
+    /** Clear all results asynchronously. */
+    clearAsync(): Promise<void>;
+};
+/**
+ * Generic key-value store interface.
+ * Implement this for Redis, DynamoDB, etc.
+ */
+interface KeyValueStore {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, options?: {
+        ttl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    keys(pattern: string): Promise<string[]>;
+}
+/**
+ * Options for key-value store cache adapter.
+ */
+interface KVCacheOptions {
+    /**
+     * Key-value store implementation.
+     */
+    store: KeyValueStore;
+    /**
+     * Key prefix for all cache entries.
+     * @default 'workflow:'
+     */
+    prefix?: string;
+    /**
+     * Time-to-live in seconds for cache entries.
+     */
+    ttl?: number;
+}
+/**
+ * Create a StepCache backed by a key-value store (Redis, DynamoDB, etc.).
+ *
+ * @param options - Cache options
+ * @returns StepCache implementation with async methods
+ *
+ * @example
+ * ```typescript
+ * // With Redis
+ * import { createClient } from 'redis';
+ *
+ * const redis = createClient();
+ * await redis.connect();
+ *
+ * const cache = createKVCache({
+ *   store: {
+ *     get: (key) => redis.get(key),
+ *     set: (key, value, opts) => redis.set(key, value, { EX: opts?.ttl }),
+ *     delete: (key) => redis.del(key).then(n => n > 0),
+ *     exists: (key) => redis.exists(key).then(n => n > 0),
+ *     keys: (pattern) => redis.keys(pattern),
+ *   },
+ *   prefix: 'myapp:workflow:',
+ *   ttl: 3600, // 1 hour
+ * });
+ * ```
+ */
+declare function createKVCache(options: KVCacheOptions): StepCache & {
+    /** Get a result asynchronously. */
+    getAsync(key: string): Promise<Result<unknown, unknown, unknown> | undefined>;
+    /** Set a result asynchronously. */
+    setAsync(key: string, result: Result<unknown, unknown, unknown>): Promise<void>;
+    /** Check if key exists asynchronously. */
+    hasAsync(key: string): Promise<boolean>;
+    /** Delete a result asynchronously. */
+    deleteAsync(key: string): Promise<boolean>;
+    /** Clear all results asynchronously. */
+    clearAsync(): Promise<void>;
+};
+/**
+ * Interface for persisting workflow state.
+ */
+interface StatePersistence {
+    /**
+     * Save workflow state.
+     */
+    save(runId: string, state: ResumeState, metadata?: Record<string, unknown>): Promise<void>;
+    /**
+     * Load workflow state.
+     */
+    load(runId: string): Promise<ResumeState | undefined>;
+    /**
+     * Delete workflow state.
+     */
+    delete(runId: string): Promise<boolean>;
+    /**
+     * List all saved workflow IDs.
+     */
+    list(): Promise<string[]>;
+}
+/**
+ * Create a state persistence adapter using a key-value store.
+ *
+ * @param store - Key-value store implementation
+ * @param prefix - Key prefix for state entries
+ * @returns StatePersistence implementation
+ */
+declare function createStatePersistence(store: KeyValueStore, prefix?: string): StatePersistence;
+/**
+ * Create a cache that hydrates from persistent storage on first access.
+ *
+ * @param memoryCache - In-memory cache for fast access
+ * @param persistence - Persistent storage for durability
+ * @returns Hydrating cache implementation
+ */
+declare function createHydratingCache(memoryCache: StepCache, persistence: StatePersistence, runId: string): StepCache & {
+    hydrate(): Promise<void>;
+};
+
+/**
+ * Workflow Versioning and Migration
+ *
+ * Handle schema changes when resuming workflows that were persisted
+ * with older step shapes.
+ *
+ * @example
+ * ```typescript
+ * import { createVersionedWorkflow } from 'awaitly';
+ *
+ * const workflow = createVersionedWorkflow(
+ *   { fetchUser, chargeCard },
+ *   {
+ *     version: 2,
+ *     migrations: {
+ *       1: (state) => migrateV1ToV2(state),
+ *     },
+ *     resumeState: loadState(runId),
+ *   }
+ * );
+ * ```
+ */
+
+/**
+ * Version number type.
+ */
+type Version = number;
+/**
+ * Migration function that transforms state from one version to the next.
+ */
+type MigrationFn = (state: ResumeState) => ResumeState | Promise<ResumeState>;
+/**
+ * Map of migrations keyed by the source version.
+ * Migration at key N transforms state from version N to version N+1.
+ */
+type Migrations = Record<Version, MigrationFn>;
+/**
+ * Versioned state includes the version number.
+ */
+interface VersionedState {
+    version: Version;
+    state: ResumeState;
+}
+/**
+ * Configuration for versioned workflow.
+ */
+interface VersionedWorkflowConfig {
+    /**
+     * Current workflow version.
+     */
+    version: Version;
+    /**
+     * Migrations for upgrading old states.
+     * Key is the source version, value transforms to next version.
+     */
+    migrations?: Migrations;
+    /**
+     * Strict mode - fail if state version is higher than current.
+     * @default true
+     */
+    strictVersioning?: boolean;
+}
+/**
+ * Error when version migration fails.
+ */
+interface MigrationError {
+    type: "MIGRATION_ERROR";
+    fromVersion: Version;
+    toVersion: Version;
+    cause: unknown;
+}
+/**
+ * Error when state version is incompatible.
+ */
+interface VersionIncompatibleError {
+    type: "VERSION_INCOMPATIBLE";
+    stateVersion: Version;
+    currentVersion: Version;
+    reason: string;
+}
+/**
+ * Type guard for MigrationError.
+ */
+declare function isMigrationError(error: unknown): error is MigrationError;
+/**
+ * Type guard for VersionIncompatibleError.
+ */
+declare function isVersionIncompatibleError(error: unknown): error is VersionIncompatibleError;
+/**
+ * Migrate state from one version to another.
+ *
+ * @param state - The versioned state to migrate
+ * @param targetVersion - The target version
+ * @param migrations - Migration functions
+ * @returns The migrated state or an error
+ *
+ * @example
+ * ```typescript
+ * const migrated = await migrateState(
+ *   { version: 1, state: oldState },
+ *   3,
+ *   {
+ *     1: (s) => transformV1ToV2(s),
+ *     2: (s) => transformV2ToV3(s),
+ *   }
+ * );
+ * ```
+ */
+declare function migrateState(state: VersionedState, targetVersion: Version, migrations: Migrations): Promise<Result<VersionedState, MigrationError | VersionIncompatibleError>>;
+/**
+ * Create a versioned resume state loader.
+ *
+ * This wraps a state loader to automatically apply migrations
+ * when loading older state versions.
+ *
+ * @param config - Versioning configuration
+ * @returns A function that loads and migrates state
+ *
+ * @example
+ * ```typescript
+ * const loadVersionedState = createVersionedStateLoader({
+ *   version: 3,
+ *   migrations: {
+ *     1: migrateV1ToV2,
+ *     2: migrateV2ToV3,
+ *   },
+ * });
+ *
+ * // In workflow
+ * const workflow = createWorkflow(deps, {
+ *   resumeState: () => loadVersionedState(savedState),
+ * });
+ * ```
+ */
+declare function createVersionedStateLoader(config: VersionedWorkflowConfig): (versionedState: VersionedState | null | undefined) => Promise<Result<ResumeState | undefined, MigrationError | VersionIncompatibleError>>;
+/**
+ * Create versioned state from current resume state.
+ *
+ * Use this when saving state to storage.
+ *
+ * @param state - The current resume state
+ * @param version - The current workflow version
+ * @returns A versioned state object
+ *
+ * @example
+ * ```typescript
+ * const collector = createStepCollector();
+ * // ... run workflow ...
+ *
+ * const versionedState = createVersionedState(collector.getState(), 2);
+ * await db.saveWorkflowState(workflowId, versionedState);
+ * ```
+ */
+declare function createVersionedState(state: ResumeState, version: Version): VersionedState;
+/**
+ * Parse versioned state from JSON.
+ *
+ * Handles the serialization/deserialization of ResumeState with Map.
+ *
+ * @param json - The JSON string or parsed object
+ * @returns The versioned state or null if invalid
+ *
+ * @example
+ * ```typescript
+ * const json = await db.loadWorkflowState(workflowId);
+ * const versionedState = parseVersionedState(json);
+ * if (versionedState) {
+ *   const loader = createVersionedStateLoader(config);
+ *   const state = await loader(versionedState);
+ * }
+ * ```
+ */
+interface SerializedVersionedState {
+    version: number;
+    state: {
+        steps: Array<[string, ResumeStateEntry]>;
+    };
+}
+declare function parseVersionedState(json: string | SerializedVersionedState | null | undefined): VersionedState | null;
+/**
+ * Serialize versioned state to JSON.
+ *
+ * Converts the Map to an array for JSON serialization.
+ *
+ * @param state - The versioned state
+ * @returns JSON string
+ *
+ * @example
+ * ```typescript
+ * const json = stringifyVersionedState(versionedState);
+ * await db.saveWorkflowState(workflowId, json);
+ * ```
+ */
+declare function stringifyVersionedState(state: VersionedState): string;
+/**
+ * Create a migration that renames step keys.
+ *
+ * @param renames - Map of old key to new key
+ * @returns A migration function
+ *
+ * @example
+ * ```typescript
+ * const migrations = {
+ *   1: createKeyRenameMigration({
+ *     'user:fetch': 'user:load',
+ *     'order:create': 'order:submit',
+ *   }),
+ * };
+ * ```
+ */
+declare function createKeyRenameMigration(renames: Record<string, string>): MigrationFn;
+/**
+ * Create a migration that removes specific step keys.
+ *
+ * @param keysToRemove - Array of keys to remove
+ * @returns A migration function
+ *
+ * @example
+ * ```typescript
+ * const migrations = {
+ *   1: createKeyRemoveMigration(['deprecated:step', 'old:cache']),
+ * };
+ * ```
+ */
+declare function createKeyRemoveMigration(keysToRemove: string[]): MigrationFn;
+/**
+ * Create a migration that transforms step values.
+ *
+ * @param transforms - Map of key to transform function
+ * @returns A migration function
+ *
+ * @example
+ * ```typescript
+ * const migrations = {
+ *   1: createValueTransformMigration({
+ *     'user:fetch': (entry) => ({
+ *       ...entry,
+ *       result: entry.result.ok
+ *         ? ok({ ...entry.result.value, newField: 'default' })
+ *         : entry.result,
+ *     }),
+ *   }),
+ * };
+ * ```
+ */
+declare function createValueTransformMigration(transforms: Record<string, (entry: ResumeStateEntry) => ResumeStateEntry>): MigrationFn;
+/**
+ * Compose multiple migrations into a single migration.
+ *
+ * @param migrations - Array of migration functions
+ * @returns A single migration function that applies all migrations in order
+ *
+ * @example
+ * ```typescript
+ * const migrations = {
+ *   1: composeMigrations([
+ *     createKeyRenameMigration({ 'old': 'new' }),
+ *     createKeyRemoveMigration(['deprecated']),
+ *   ]),
+ * };
+ * ```
+ */
+declare function composeMigrations(migrations: MigrationFn[]): MigrationFn;
+
+export { type FileCacheOptions, type FileSystemInterface, type KVCacheOptions, type KeyValueStore, type MemoryCacheOptions, type MigrationError, type MigrationFn, type Migrations, type SerializedCause, type SerializedEntry, type SerializedMeta, type SerializedResult, type SerializedState, type StatePersistence, type Version, type VersionIncompatibleError, type VersionedState, type VersionedWorkflowConfig, composeMigrations, createFileCache, createHydratingCache, createKVCache, createKeyRemoveMigration, createKeyRenameMigration, createMemoryCache, createStatePersistence, createValueTransformMigration, createVersionedState, createVersionedStateLoader, deserializeCause, deserializeEntry, deserializeMeta, deserializeResult, deserializeState, isMigrationError, isVersionIncompatibleError, migrateState, parseState, parseVersionedState, serializeCause, serializeEntry, serializeMeta, serializeResult, serializeState, stringifyState, stringifyVersionedState };

package/dist/persistence.js

@@ -0,0 +1,2 @@
+var I=e=>({ok:!0,value:e}),h=(e,n)=>({ok:!1,error:e,...n?.cause!==void 0?{cause:n.cause}:{}});var de=e=>typeof e=="object"&&e!==null&&e.type==="UNEXPECTED_ERROR",N=Symbol.for("step_timeout_marker");function re(e){return typeof e!="object"||e===null?!1:e.type==="STEP_TIMEOUT"?!0:N in e}function we(e){if(!(typeof e!="object"||e===null)){if(e.type==="STEP_TIMEOUT"){let n=e;return{timeoutMs:n.timeoutMs,stepName:n.stepName,stepKey:n.stepKey,attempt:n.attempt}}if(N in e)return e[N]}}var ue=Symbol("early-exit");function fe(e,n){return{[ue]:!0,error:e,meta:n}}function ke(e){return typeof e=="object"&&e!==null&&e[ue]===!0}var ie=Symbol("mapper-exception");function Te(e){return{[ie]:!0,thrown:e}}function Re(e){return typeof e=="object"&&e!==null&&e[ie]===!0}function ge(e){return typeof e=="string"?{name:e}:e??{}}function Z(e,n){let{backoff:u,initialDelay:o,maxDelay:s,jitter:i}=n,r;switch(u){case"fixed":r=o;break;case"linear":r=o*e;break;case"exponential":r=o*Math.pow(2,e-1);break}if(r=Math.min(r,s),i){let t=r*.25*Math.random();r=r+t}return Math.floor(r)}function Q(e){return new Promise(n=>setTimeout(n,e))}var oe=Symbol("timeout");async function Ce(e,n,u){let o=new AbortController,s=n.error??{type:"STEP_TIMEOUT",stepName:u.name,stepKey:u.key,timeoutMs:n.ms,attempt:u.attempt},i,r=new Promise((k,w)=>{i=setTimeout(()=>{o.abort(),w({[oe]:!0,error:s})},n.ms)}),t;n.signal?t=Promise.resolve(e(o.signal)):t=Promise.resolve(e());try{return await Promise.race([t,r])}catch(k){if(typeof k=="object"&&k!==null&&k[oe]===!0){let w=k.error;if(typeof w=="object"&&w!==null&&w.type!=="STEP_TIMEOUT"){let _={timeoutMs:n.ms,stepName:u.name,stepKey:u.key,attempt:u.attempt};N in w?w[N]=_:Object.defineProperty(w,N,{value:_,enumerable:!1,writable:!0,configurable:!1})}throw w}throw k}finally{clearTimeout(i)}}var F={backoff:"exponential",initialDelay:100,maxDelay:3e4,jitter:!0,retryOn:()=>!0,onRetry:()=>{}};async function se(e,n){let{onError:u,onEvent:o,catchUnexpected:s,workflowId:i,context:r}=n&&typeof n=="object"?n:{},t=i??crypto.randomUUID(),k=!u&&!s,w=[],_=0,B=l=>l??`step_${++_}`,d=l=>{let P=l.context!==void 0||r===void 0?l:{...l,context:r};if(P.type==="step_success"){let O=P.stepId;for(let K=w.length-1;K>=0;K--){let z=w[K];if(z.type==="race"&&!z.winnerId){z.winnerId=O;break}}}o?.(P,r)},V=fe,te=l=>ke(l),Y=(l,P)=>k?P?.origin==="result"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:l,...P.resultCause!==void 0?{cause:P.resultCause}:{}}}:P?.origin==="throw"?{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"throw",error:l,thrown:P.thrown}}:{type:"UNEXPECTED_ERROR",cause:{type:"STEP_FAILURE",origin:"result",error:l}}:l,Ee=l=>({type:"UNEXPECTED_ERROR",cause:l.meta.origin==="result"?{type:"STEP_FAILURE",origin:"result",error:l.error,...l.meta.resultCause!==void 0?{cause:l.meta.resultCause}:{}}:{type:"STEP_FAILURE",origin:"throw",error:l.error,thrown:l.meta.thrown}});try{let P=function(T,y){let p=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let a=performance.now(),c=!1;w.push({scopeId:p,type:"parallel"});let S=()=>{if(c)return;c=!0;let m=w.findIndex(E=>E.scopeId===p);m!==-1&&w.splice(m,1),d({type:"scope_end",workflowId:t,scopeId:p,ts:Date.now(),durationMs:performance.now()-a})};d({type:"scope_start",workflowId:t,scopeId:p,scopeType:"parallel",name:T,ts:Date.now()});try{let m=await y();if(S(),!m.ok)throw u?.(m.error,T,r),V(m.error,{origin:"result",resultCause:m.cause});return m.value}catch(m){throw S(),m}})()},O=function(T,y){let p=Object.keys(T),a=y.name??`Parallel(${p.join(", ")})`,c=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let S=performance.now(),m=!1;w.push({scopeId:c,type:"parallel"});let E=()=>{if(m)return;m=!0;let R=w.findIndex(C=>C.scopeId===c);R!==-1&&w.splice(R,1),d({type:"scope_end",workflowId:t,scopeId:c,ts:Date.now(),durationMs:performance.now()-S})};d({type:"scope_start",workflowId:t,scopeId:c,scopeType:"parallel",name:a,ts:Date.now()});try{let R=await new Promise(A=>{if(p.length===0){A([]);return}let b=!1,x=p.length,j=new Array(p.length);for(let M=0;M<p.length;M++){let D=p[M],G=M;Promise.resolve(T[D]()).catch(g=>h({type:"PROMISE_REJECTED",cause:g},{cause:{type:"PROMISE_REJECTION",reason:g}})).then(g=>{if(!b){if(!g.ok){b=!0,A([{key:D,result:g}]);return}j[G]={key:D,result:g},x--,x===0&&A(j)}})}});E();let C={};for(let{key:A,result:b}of R){if(!b.ok)throw u?.(b.error,A,r),V(b.error,{origin:"result",resultCause:b.cause});C[A]=b.value}return C}catch(R){throw E(),R}})()};var ze=P,je=O;let l=(T,y)=>(async()=>{let p=ge(y),{name:a,key:c,retry:S,timeout:m}=p,E=B(c),R=o,C=R?performance.now():0;if(!(typeof T=="function")){if(S&&S.attempts>1)throw new Error("step: retry options require a function operation. Direct Promise/Result values cannot be re-executed on retry. Wrap your operation in a function: step(() => yourOperation, { retry: {...} })");if(m)throw new Error("step: timeout options require a function operation. Direct Promise/Result values cannot be wrapped with timeout after they've started. Wrap your operation in a function: step(() => yourOperation, { timeout: {...} })")}let x={attempts:Math.max(1,S?.attempts??1),backoff:S?.backoff??F.backoff,initialDelay:S?.initialDelay??F.initialDelay,maxDelay:S?.maxDelay??F.maxDelay,jitter:S?.jitter??F.jitter,retryOn:S?.retryOn??F.retryOn,onRetry:S?.onRetry??F.onRetry};o&&d({type:"step_start",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now()});let j;for(let g=1;g<=x.attempts;g++){let me=R?performance.now():0;try{let f;if(typeof T=="function"?m?f=await Ce(T,m,{name:a,key:c,attempt:g}):f=await T():f=await T,f.ok){let U=performance.now()-C;return d({type:"step_success",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:U}),c&&d({type:"step_complete",workflowId:t,stepKey:c,name:a,ts:Date.now(),durationMs:U,result:f}),f.value}if(j=f,g<x.attempts&&x.retryOn(f.error,g)){let U=Z(g,x);d({type:"step_retry",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),attempt:g+1,maxAttempts:x.attempts,delayMs:U,error:f.error}),x.onRetry(f.error,g,U),await Q(U);continue}x.attempts>1&&d({type:"step_retries_exhausted",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:performance.now()-C,attempts:g,lastError:f.error});break}catch(f){let U=performance.now()-me;if(te(f))throw d({type:"step_aborted",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:U}),f;if(re(f)){let v=we(f),q=m?.ms??v?.timeoutMs??0;if(d({type:"step_timeout",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),timeoutMs:q,attempt:g}),g<x.attempts&&x.retryOn(f,g)){let H=Z(g,x);d({type:"step_retry",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),attempt:g+1,maxAttempts:x.attempts,delayMs:H,error:f}),x.onRetry(f,g,H),await Q(H);continue}x.attempts>1&&d({type:"step_retries_exhausted",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:performance.now()-C,attempts:g,lastError:f})}if(g<x.attempts&&x.retryOn(f,g)){let v=Z(g,x);d({type:"step_retry",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),attempt:g+1,maxAttempts:x.attempts,delayMs:v,error:f}),x.onRetry(f,g,v),await Q(v);continue}x.attempts>1&&!re(f)&&d({type:"step_retries_exhausted",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:performance.now()-C,attempts:g,lastError:f});let L=performance.now()-C;if(s){let v;try{v=s(f)}catch(q){throw Te(q)}throw d({type:"step_error",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:L,error:v}),c&&d({type:"step_complete",workflowId:t,stepKey:c,name:a,ts:Date.now(),durationMs:L,result:h(v,{cause:f}),meta:{origin:"throw",thrown:f}}),u?.(v,a,r),V(v,{origin:"throw",thrown:f})}else{let v={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:f}};throw d({type:"step_error",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:L,error:v}),c&&d({type:"step_complete",workflowId:t,stepKey:c,name:a,ts:Date.now(),durationMs:L,result:h(v,{cause:f}),meta:{origin:"throw",thrown:f}}),f}}}let M=j,D=performance.now()-C,G=Y(M.error,{origin:"result",resultCause:M.cause});throw d({type:"step_error",workflowId:t,stepId:E,stepKey:c,name:a,ts:Date.now(),durationMs:D,error:G}),c&&d({type:"step_complete",workflowId:t,stepKey:c,name:a,ts:Date.now(),durationMs:D,result:M,meta:{origin:"result",resultCause:M.cause}}),u?.(M.error,a,r),V(M.error,{origin:"result",resultCause:M.cause})})();l.try=(T,y)=>{let p=y.name,a=y.key,c=B(a),S="error"in y?()=>y.error:y.onError,m=o;return(async()=>{let E=m?performance.now():0;o&&d({type:"step_start",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now()});try{let R=await T(),C=performance.now()-E;return d({type:"step_success",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now(),durationMs:C}),a&&d({type:"step_complete",workflowId:t,stepKey:a,name:p,ts:Date.now(),durationMs:C,result:I(R)}),R}catch(R){let C=S(R),A=performance.now()-E,b=Y(C,{origin:"throw",thrown:R});throw d({type:"step_error",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now(),durationMs:A,error:b}),a&&d({type:"step_complete",workflowId:t,stepKey:a,name:p,ts:Date.now(),durationMs:A,result:h(C,{cause:R}),meta:{origin:"throw",thrown:R}}),u?.(C,p,r),V(C,{origin:"throw",thrown:R})}})()},l.fromResult=(T,y)=>{let p=y.name,a=y.key,c=B(a),S="error"in y?()=>y.error:y.onError,m=o;return(async()=>{let E=m?performance.now():0;o&&d({type:"step_start",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now()});let R=await T();if(R.ok){let C=performance.now()-E;return d({type:"step_success",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now(),durationMs:C}),a&&d({type:"step_complete",workflowId:t,stepKey:a,name:p,ts:Date.now(),durationMs:C,result:I(R.value)}),R.value}else{let C=S(R.error),A=performance.now()-E,b=Y(C,{origin:"result",resultCause:R.error});throw d({type:"step_error",workflowId:t,stepId:c,stepKey:a,name:p,ts:Date.now(),durationMs:A,error:b}),a&&d({type:"step_complete",workflowId:t,stepKey:a,name:p,ts:Date.now(),durationMs:A,result:h(C,{cause:R.error}),meta:{origin:"result",resultCause:R.error}}),u?.(C,p,r),V(C,{origin:"result",resultCause:R.error})}})()},l.retry=(T,y)=>l(T,{name:y.name,key:y.key,retry:{attempts:y.attempts,backoff:y.backoff,initialDelay:y.initialDelay,maxDelay:y.maxDelay,jitter:y.jitter,retryOn:y.retryOn,onRetry:y.onRetry},timeout:y.timeout}),l.withTimeout=(T,y)=>l(T,{name:y.name,key:y.key,timeout:y}),l.parallel=((...T)=>{if(typeof T[0]=="string"){let y=T[0],p=T[1];return P(y,p)}else{let y=T[0],p=T[1]??{};return O(y,p)}}),l.race=(T,y)=>{let p=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let a=performance.now(),c=!1,S={scopeId:p,type:"race",winnerId:void 0};w.push(S);let m=()=>{if(c)return;c=!0;let E=w.findIndex(R=>R.scopeId===p);E!==-1&&w.splice(E,1),d({type:"scope_end",workflowId:t,scopeId:p,ts:Date.now(),durationMs:performance.now()-a,winnerId:S.winnerId})};d({type:"scope_start",workflowId:t,scopeId:p,scopeType:"race",name:T,ts:Date.now()});try{let E=await y();if(m(),!E.ok)throw u?.(E.error,T,r),V(E.error,{origin:"result",resultCause:E.cause});return E.value}catch(E){throw m(),E}})()},l.allSettled=(T,y)=>{let p=`scope_${Date.now()}_${Math.random().toString(36).slice(2,8)}`;return(async()=>{let a=performance.now(),c=!1;w.push({scopeId:p,type:"allSettled"});let S=()=>{if(c)return;c=!0;let m=w.findIndex(E=>E.scopeId===p);m!==-1&&w.splice(m,1),d({type:"scope_end",workflowId:t,scopeId:p,ts:Date.now(),durationMs:performance.now()-a})};d({type:"scope_start",workflowId:t,scopeId:p,scopeType:"allSettled",name:T,ts:Date.now()});try{let m=await y();if(S(),!m.ok)throw u?.(m.error,T,r),V(m.error,{origin:"result",resultCause:m.cause});return m.value}catch(m){throw S(),m}})()};let z=await e(l);return I(z)}catch(l){if(Re(l))throw l.thrown;if(te(l)){let O=l.meta.origin==="throw"?l.meta.thrown:l.meta.resultCause;if(s||u)return h(l.error,{cause:O});if(de(l.error))return h(l.error,{cause:O});let K=Ee(l);return h(K,{cause:O})}if(s){let O=s(l);return u?.(O,"unexpected",r),h(O,{cause:l})}let P={type:"UNEXPECTED_ERROR",cause:{type:"UNCAUGHT_EXCEPTION",thrown:l}};return u?.(P,"unexpected",r),h(P,{cause:l})}}se.strict=(e,n)=>se(e,n);function $(e){if(e===void 0)return{type:"undefined"};if(e instanceof Error)return{type:"error",errorName:e.name,errorMessage:e.message,errorStack:e.stack};try{return JSON.stringify(e),{type:"value",value:e}}catch{return{type:"value",value:String(e)}}}function W(e){if(e.type!=="undefined"){if(e.type==="error"){let n=new Error(e.errorMessage??"Unknown error");return n.name=e.errorName??"Error",e.errorStack&&(n.stack=e.errorStack),n}return e.value}}function J(e){return e.ok?{ok:!0,value:e.value}:{ok:!1,error:e.error,cause:e.cause!==void 0?$(e.cause):void 0}}function X(e){if(e.ok)return I(e.value);let n=e.cause?W(e.cause):void 0;return h(e.error,n!==void 0?{cause:n}:void 0)}function ae(e){return e.origin==="result"?{origin:"result",resultCause:e.resultCause!==void 0?$(e.resultCause):void 0}:{origin:"throw",thrown:$(e.thrown)}}function le(e){return e.origin==="result"?{origin:"result",resultCause:e.resultCause?W(e.resultCause):void 0}:{origin:"throw",thrown:e.thrown?W(e.thrown):void 0}}function ce(e){return{result:J(e.result),meta:e.meta?ae(e.meta):void 0}}function pe(e){return{result:X(e.result),meta:e.meta?le(e.meta):void 0}}function ee(e,n){let u={};for(let[o,s]of e.steps)u[o]=ce(s);return{version:1,entries:u,metadata:n}}function ne(e){let n=new Map;for(let[u,o]of Object.entries(e.entries))n.set(u,pe(o));return{steps:n}}function Se(e,n){return JSON.stringify(ee(e,n))}function xe(e){let n=JSON.parse(e);return ne(n)}function he(e={}){let{maxSize:n,ttl:u}=e,o=new Map,s=t=>u?Date.now()-t>u:!1,i=()=>{if(u)for(let[t,k]of o)s(k.timestamp)&&o.delete(t)},r=()=>{if(!n||o.size<n)return;let t,k=1/0;for(let[w,_]of o)_.timestamp<k&&(k=_.timestamp,t=w);t&&o.delete(t)};return{get(t){i();let k=o.get(t);if(k){if(s(k.timestamp)){o.delete(t);return}return k.result}},set(t,k){i(),r(),o.set(t,{result:k,timestamp:Date.now()})},has(t){i();let k=o.get(t);return k?s(k.timestamp)?(o.delete(t),!1):!0:!1},delete(t){return o.delete(t)},clear(){o.clear()}}}function Pe(e){let{directory:n,extension:u=".json",fs:o}=e;if(!o)throw new Error("File system interface is required. Pass fs option with readFile, writeFile, etc.");let s=r=>{let t=r.replace(/[^a-zA-Z0-9_-]/g,"_");return`${n}/${t}${u}`},i=new Map;return{async init(){await o.mkdir(n,{recursive:!0})},get(r){return i.get(r)},async getAsync(r){let t=s(r);try{if(!await o.exists(t))return;let k=await o.readFile(t),w=JSON.parse(k),_=X(w);return i.set(r,_),_}catch{return}},set(r,t){i.set(r,t)},async setAsync(r,t){let k=s(r),w=J(t);await o.writeFile(k,JSON.stringify(w,null,2)),i.set(r,t)},has(r){return i.has(r)},delete(r){return i.delete(r)},async deleteAsync(r){let t=s(r);try{return await o.unlink(t),i.delete(r),!0}catch{return!1}},clear(){i.clear()},async clearAsync(){try{let r=await o.readdir(n);for(let t of r)t.endsWith(u)&&await o.unlink(`${n}/${t}`);i.clear()}catch{}}}}function ve(e){let{store:n,prefix:u="workflow:",ttl:o}=e,s=r=>`${u}${r}`,i=new Map;return{get(r){return i.get(r)},async getAsync(r){let t=await n.get(s(r));if(t)try{let k=JSON.parse(t),w=X(k);return i.set(r,w),w}catch{return}},set(r,t){i.set(r,t)},async setAsync(r,t){let k=J(t);await n.set(s(r),JSON.stringify(k),o?{ttl:o}:void 0),i.set(r,t)},has(r){return i.has(r)},async hasAsync(r){return n.exists(s(r))},delete(r){return i.delete(r)},async deleteAsync(r){return i.delete(r),n.delete(s(r))},clear(){i.clear()},async clearAsync(){let r=await n.keys(`${u}*`);for(let t of r)await n.delete(t);i.clear()}}}function Ae(e,n="workflow:state:"){let u=o=>`${n}${o}`;return{async save(o,s,i){let r=ee(s,i);await e.set(u(o),JSON.stringify(r))},async load(o){let s=await e.get(u(o));if(s)try{let i=JSON.parse(s);return ne(i)}catch{return}},async delete(o){return e.delete(u(o))},async list(){return(await e.keys(`${n}*`)).map(s=>s.slice(n.length))}}}function be(e,n,u){let o=!1;return{async hydrate(){if(o)return;let s=await n.load(u);if(s)for(let[i,r]of s.steps)e.set(i,r.result);o=!0},get(s){return e.get(s)},set(s,i){e.set(s,i)},has(s){return e.has(s)},delete(s){return e.delete(s)},clear(){e.clear()}}}function Me(e){return typeof e=="object"&&e!==null&&e.type==="MIGRATION_ERROR"}function Oe(e){return typeof e=="object"&&e!==null&&e.type==="VERSION_INCOMPATIBLE"}async function ye(e,n,u){let o=e.state,s=e.version;if(s>n)return h({type:"VERSION_INCOMPATIBLE",stateVersion:s,currentVersion:n,reason:"State version is higher than current workflow version. Cannot downgrade."});if(s===n)return I({version:s,state:o});for(;s<n;){let i=u[s];if(!i)return h({type:"VERSION_INCOMPATIBLE",stateVersion:e.version,currentVersion:n,reason:`No migration found for version ${s} to ${s+1}`});try{o=await i(o),s++}catch(r){return h({type:"MIGRATION_ERROR",fromVersion:s,toVersion:s+1,cause:r})}}return I({version:s,state:o})}function Ie(e){let{version:n,migrations:u={},strictVersioning:o=!0}=e;return async s=>{if(!s)return I(void 0);if(o&&s.version>n)return h({type:"VERSION_INCOMPATIBLE",stateVersion:s.version,currentVersion:n,reason:"Saved state is from a newer workflow version"});if(s.version===n)return I(s.state);let i=await ye(s,n,u);return i.ok?I(i.value.state):i}}function _e(e,n){return{version:n,state:e}}function Ve(e){if(!e)return null;try{let n=typeof e=="string"?JSON.parse(e):e;if(typeof n!="object"||n===null||!("version"in n)||typeof n.version!="number"||!("state"in n)||!n.state||!Array.isArray(n.state.steps))return null;let u=n,o=new Map(u.state.steps);return{version:u.version,state:{steps:o}}}catch{return null}}function Ue(e){return JSON.stringify({version:e.version,state:{steps:Array.from(e.state.steps.entries())}})}function Ke(e){return n=>{let u=new Map;for(let[o,s]of n.steps){let i=e[o]??o;u.set(i,s)}return{steps:u}}}function De(e){let n=new Set(e);return u=>{let o=new Map;for(let[s,i]of u.steps)n.has(s)||o.set(s,i);return{steps:o}}}function Fe(e){return n=>{let u=new Map;for(let[o,s]of n.steps){let i=e[o];u.set(o,i?i(s):s)}return{steps:u}}}function Ne(e){return async n=>{let u=n;for(let o of e)u=await o(u);return u}}export{Ne as composeMigrations,Pe as createFileCache,be as createHydratingCache,ve as createKVCache,De as createKeyRemoveMigration,Ke as createKeyRenameMigration,he as createMemoryCache,Ae as createStatePersistence,Fe as createValueTransformMigration,_e as createVersionedState,Ie as createVersionedStateLoader,W as deserializeCause,pe as deserializeEntry,le as deserializeMeta,X as deserializeResult,ne as deserializeState,Me as isMigrationError,Oe as isVersionIncompatibleError,ye as migrateState,xe as parseState,Ve as parseVersionedState,$ as serializeCause,ce as serializeEntry,ae as serializeMeta,J as serializeResult,ee as serializeState,Se as stringifyState,Ue as stringifyVersionedState};
+//# sourceMappingURL=persistence.js.map