dotdo 0.0.1 → 0.1.0

package/dist/objects/WorkflowRuntime.js

@@ -0,0 +1,863 @@
+/**
+ * WorkflowRuntime - Manages workflow execution in Durable Objects
+ *
+ * Provides:
+ * - State management: pending, running, paused, completed, failed
+ * - Step registration and ordered execution
+ * - Integration with WaitForEventManager for event-driven pauses
+ * - Event emission for observability
+ * - Persistence across DO hibernation
+ *
+ * This is the core runtime for executing workflow definitions in DOs.
+ */
+/// <reference types="@cloudflare/workers-types" />
+import { WaitForEventManager } from '../workflows/WaitForEventManager';
+import { applyInputModifiers, applyOutputModifiers, } from '../lib/Modifier';
+import { ParallelStepExecutor, ParallelExecutionError, } from '../lib/executors/ParallelStepExecutor';
+// Re-export for convenience
+export { ParallelExecutionError } from '../lib/executors/ParallelStepExecutor';
+// ============================================================================
+// ERRORS
+// ============================================================================
+export class WorkflowStateError extends Error {
+    currentState;
+    attemptedAction;
+    constructor(currentState, attemptedAction) {
+        super(`Cannot ${attemptedAction} workflow in '${currentState}' state`);
+        this.name = 'WorkflowStateError';
+        this.currentState = currentState;
+        this.attemptedAction = attemptedAction;
+    }
+}
+export class WorkflowStepError extends Error {
+    stepName;
+    stepIndex;
+    cause;
+    constructor(stepName, stepIndex, cause) {
+        super(`Step '${stepName}' (index ${stepIndex}) failed: ${cause?.message || 'Unknown error'}`);
+        this.name = 'WorkflowStepError';
+        this.stepName = stepName;
+        this.stepIndex = stepIndex;
+        this.cause = cause;
+    }
+}
+export class WorkflowTimeoutError extends Error {
+    stepName;
+    timeoutMs;
+    constructor(timeoutMs, stepName) {
+        const context = stepName ? `Step '${stepName}'` : 'Workflow';
+        super(`${context} timed out after ${timeoutMs}ms`);
+        this.name = 'WorkflowTimeoutError';
+        this.stepName = stepName;
+        this.timeoutMs = timeoutMs;
+    }
+}
+// ============================================================================
+// DURATION PARSING
+// ============================================================================
+function parseDuration(duration) {
+    if (typeof duration === 'number') {
+        return duration;
+    }
+    // Support formats like "100ms", "1 second", "30 seconds", "1 hour", etc.
+    const match = duration.match(/^(\d+(?:\.\d+)?)\s*(ms|millisecond|s|sec|second|m|min|minute|h|hr|hour|d|day|w|week)s?$/i);
+    if (!match) {
+        throw new Error(`Invalid duration format: ${duration}`);
+    }
+    const value = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    const multipliers = {
+        ms: 1,
+        millisecond: 1,
+        s: 1000,
+        sec: 1000,
+        second: 1000,
+        m: 60 * 1000,
+        min: 60 * 1000,
+        minute: 60 * 1000,
+        h: 60 * 60 * 1000,
+        hr: 60 * 60 * 1000,
+        hour: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        day: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+        week: 7 * 24 * 60 * 60 * 1000,
+    };
+    return value * (multipliers[unit] || 1000);
+}
+export class WorkflowRuntime {
+    storage;
+    config;
+    _options;
+    _instanceId;
+    waitForEventManager;
+    eventHandlers = new Map();
+    _state = 'pending';
+    _steps = [];
+    _stepResults = [];
+    _currentStepIndex = 0;
+    _input = undefined;
+    _output = undefined;
+    _error = undefined;
+    _startedAt = undefined;
+    _completedAt = undefined;
+    _pendingEvents = [];
+    _initialized = false;
+    _parallelGroupCounter = 0;
+    // For waitForEvent resolution
+    waitResolvers = new Map();
+    // ==========================================================================
+    // CONSTRUCTOR
+    // ==========================================================================
+    constructor(state, config, options = {}) {
+        this.storage = state.storage;
+        this.config = config;
+        this._options = {
+            retries: 0,
+            onError: 'fail',
+            ...options,
+        };
+        this._instanceId = crypto.randomUUID();
+        this.waitForEventManager = new WaitForEventManager(state);
+    }
+    // ==========================================================================
+    // GETTERS
+    // ==========================================================================
+    get name() {
+        return this.config.name;
+    }
+    get version() {
+        return this.config.version;
+    }
+    get instanceId() {
+        return this._instanceId;
+    }
+    get state() {
+        return this._state;
+    }
+    get options() {
+        return this._options;
+    }
+    get steps() {
+        return this._steps;
+    }
+    get stepResults() {
+        return this._stepResults;
+    }
+    get currentStepIndex() {
+        return this._currentStepIndex;
+    }
+    get input() {
+        return this._input;
+    }
+    get output() {
+        return this._output;
+    }
+    get error() {
+        return this._error;
+    }
+    get startedAt() {
+        return this._startedAt;
+    }
+    get completedAt() {
+        return this._completedAt;
+    }
+    get pendingEvents() {
+        return this._pendingEvents;
+    }
+    get duration() {
+        if (!this._startedAt)
+            return undefined;
+        const endTime = this._completedAt || new Date();
+        return endTime.getTime() - this._startedAt.getTime();
+    }
+    // ==========================================================================
+    // INITIALIZATION
+    // ==========================================================================
+    async initialize() {
+        if (this._initialized)
+            return;
+        await this.storage.put('workflow:config', this.config);
+        await this.persistState();
+        this._initialized = true;
+    }
+    // ==========================================================================
+    // STEP REGISTRATION
+    // ==========================================================================
+    registerStep(name, handler, config) {
+        if (this._state !== 'pending') {
+            throw new Error('Cannot register steps after workflow has started');
+        }
+        this._steps.push({ name, handler, config });
+    }
+    /**
+     * Fluent API for step registration
+     */
+    step(name, handler, config) {
+        this.registerStep(name, handler, config);
+        return this;
+    }
+    /**
+     * Register a group of steps to execute in parallel
+     *
+     * @example
+     * ```typescript
+     * workflow
+     *   .step('validate', validateOrder)
+     *   .parallel([
+     *     step('checkInventory', checkStock),
+     *     step('checkPayment', validatePayment),
+     *     step('checkShipping', calculateShipping),
+     *   ])
+     *   .step('confirm', confirmOrder)
+     * ```
+     */
+    parallel(steps, options = {}) {
+        if (this._state !== 'pending') {
+            throw new Error('Cannot register steps after workflow has started');
+        }
+        // Validate: at least 2 steps required
+        if (!steps || steps.length < 2) {
+            throw new Error('Parallel execution requires at least two steps');
+        }
+        // Validate: unique step names
+        const names = new Set();
+        for (const step of steps) {
+            if (names.has(step.name)) {
+                throw new Error(`Duplicate step name in parallel group: ${step.name}`);
+            }
+            names.add(step.name);
+        }
+        // Generate group name if not provided
+        const groupName = options.name || `parallel-${this._parallelGroupCounter++}`;
+        // Create a placeholder handler that will be handled specially in executeStep
+        const parallelHandler = async (ctx) => {
+            // This is a placeholder - actual execution happens in executeStep
+            throw new Error('Parallel handler should not be called directly');
+        };
+        this._steps.push({
+            name: groupName,
+            handler: parallelHandler,
+            isParallel: true,
+            parallelSteps: steps,
+            parallelOptions: options,
+        });
+        return this;
+    }
+    // ==========================================================================
+    // LIFECYCLE METHODS
+    // ==========================================================================
+    async start(input) {
+        if (this._state !== 'pending') {
+            throw new WorkflowStateError(this._state, 'start');
+        }
+        this._input = input;
+        this._state = 'running';
+        this._startedAt = new Date();
+        this._initialized = true;
+        await this.persistState();
+        this.emit('workflow.started', { instanceId: this._instanceId, input });
+        try {
+            await this.executeSteps();
+            if (this._state === 'running') {
+                this._state = 'completed';
+                this._completedAt = new Date();
+                this._output = this._stepResults[this._stepResults.length - 1]?.output;
+                await this.persistState();
+                this.emit('workflow.completed', {
+                    instanceId: this._instanceId,
+                    output: this._output,
+                    duration: this.duration,
+                });
+            }
+            return {
+                status: this._state,
+                output: this._output,
+                duration: this.duration,
+            };
+        }
+        catch (error) {
+            if (this._options.onError === 'pause') {
+                this._state = 'paused';
+                this._error = error instanceof Error ? error : new Error(String(error));
+                await this.persistState();
+                this.emit('workflow.paused', {
+                    instanceId: this._instanceId,
+                    reason: 'error',
+                    error: this._error,
+                });
+                return {
+                    status: this._state,
+                    error: this._error,
+                    duration: this.duration,
+                };
+            }
+            this._state = 'failed';
+            this._error = error instanceof Error ? error : new Error(String(error));
+            this._completedAt = new Date();
+            await this.persistState();
+            this.emit('workflow.failed', {
+                instanceId: this._instanceId,
+                error: { message: this._error.message, name: this._error.name },
+                duration: this.duration,
+            });
+            throw error;
+        }
+    }
+    async pause() {
+        if (this._state !== 'running') {
+            throw new WorkflowStateError(this._state, 'pause');
+        }
+        this._state = 'paused';
+        await this.persistState();
+        this.emit('workflow.paused', { instanceId: this._instanceId });
+    }
+    async resume() {
+        if (this._state !== 'paused') {
+            throw new WorkflowStateError(this._state, 'resume');
+        }
+        this._state = 'running';
+        this._error = undefined; // Clear error on resume
+        await this.persistState();
+        this.emit('workflow.resumed', { instanceId: this._instanceId });
+        // Continue execution from current step
+        try {
+            await this.executeSteps();
+            if (this._state === 'running') {
+                this._state = 'completed';
+                this._completedAt = new Date();
+                this._output = this._stepResults[this._stepResults.length - 1]?.output;
+                await this.persistState();
+                this.emit('workflow.completed', {
+                    instanceId: this._instanceId,
+                    output: this._output,
+                    duration: this.duration,
+                });
+            }
+        }
+        catch (error) {
+            if (this._options.onError === 'pause') {
+                this._state = 'paused';
+                this._error = error instanceof Error ? error : new Error(String(error));
+                await this.persistState();
+                return;
+            }
+            this._state = 'failed';
+            this._error = error instanceof Error ? error : new Error(String(error));
+            this._completedAt = new Date();
+            await this.persistState();
+            this.emit('workflow.failed', {
+                instanceId: this._instanceId,
+                error: { message: this._error.message, name: this._error.name },
+            });
+            throw error;
+        }
+    }
+    async restore() {
+        const state = await this.storage.get('workflow:state');
+        if (!state)
+            return;
+        this._state = state.status;
+        this._currentStepIndex = state.currentStepIndex;
+        this._input = state.input;
+        this._output = state.output;
+        this._pendingEvents = state.pendingEvents || [];
+        if (state.error) {
+            this._error = new Error(state.error.message);
+            this._error.name = state.error.name;
+        }
+        if (state.startedAt) {
+            this._startedAt = new Date(state.startedAt);
+        }
+        if (state.completedAt) {
+            this._completedAt = new Date(state.completedAt);
+        }
+        // Restore step results
+        const stepStates = await this.storage.list({ prefix: 'workflow:step:' });
+        for (const [key, stepState] of stepStates) {
+            const indexMatch = key.match(/workflow:step:(\d+)/);
+            if (indexMatch) {
+                const index = parseInt(indexMatch[1], 10);
+                this._stepResults[index] = {
+                    name: stepState.name,
+                    status: stepState.status,
+                    output: stepState.output,
+                    duration: stepState.duration,
+                    startedAt: stepState.startedAt ? new Date(stepState.startedAt) : undefined,
+                    completedAt: stepState.completedAt ? new Date(stepState.completedAt) : undefined,
+                };
+                if (stepState.error) {
+                    this._stepResults[index].error = new Error(stepState.error.message);
+                    this._stepResults[index].error.name = stepState.error.name;
+                }
+            }
+        }
+        // Restore parallel step results
+        const parallelStates = await this.storage.list({ prefix: 'workflow:parallel:' });
+        for (const [key, parallelState] of parallelStates) {
+            // Key format: workflow:parallel:{stepIndex}:{stepName}
+            const match = key.match(/workflow:parallel:(\d+):(.+)/);
+            if (match) {
+                const stepIndex = parseInt(match[1], 10);
+                const parallelStepName = match[2];
+                // Ensure step result exists
+                if (!this._stepResults[stepIndex]) {
+                    this._stepResults[stepIndex] = {
+                        name: `parallel-${stepIndex}`,
+                        status: 'running',
+                        parallelResults: {},
+                    };
+                }
+                // Ensure parallelResults exists
+                if (!this._stepResults[stepIndex].parallelResults) {
+                    this._stepResults[stepIndex].parallelResults = {};
+                }
+                // Add the parallel step result
+                this._stepResults[stepIndex].parallelResults[parallelStepName] = {
+                    name: parallelState.name,
+                    status: parallelState.status,
+                    output: parallelState.output,
+                    duration: parallelState.duration,
+                    startedAt: parallelState.startedAt ? new Date(parallelState.startedAt) : undefined,
+                    completedAt: parallelState.completedAt ? new Date(parallelState.completedAt) : undefined,
+                };
+                if (parallelState.error) {
+                    this._stepResults[stepIndex].parallelResults[parallelStepName].error = new Error(parallelState.error.message);
+                    this._stepResults[stepIndex].parallelResults[parallelStepName].error.name = parallelState.error.name;
+                }
+            }
+        }
+        this._initialized = true;
+    }
+    // ==========================================================================
+    // STEP EXECUTION
+    // ==========================================================================
+    async executeSteps() {
+        while (this._currentStepIndex < this._steps.length && this._state === 'running') {
+            const step = this._steps[this._currentStepIndex];
+            const stepResult = await this.executeStep(step, this._currentStepIndex);
+            this._stepResults[this._currentStepIndex] = stepResult;
+            await this.storage.put(`workflow:step:${this._currentStepIndex}`, {
+                name: stepResult.name,
+                status: stepResult.status,
+                output: stepResult.output,
+                duration: stepResult.duration,
+                startedAt: stepResult.startedAt?.toISOString(),
+                completedAt: stepResult.completedAt?.toISOString(),
+                error: stepResult.error
+                    ? {
+                        message: stepResult.error.message,
+                        name: stepResult.error.name,
+                    }
+                    : undefined,
+            });
+            if (stepResult.status === 'failed') {
+                throw stepResult.error || new Error(`Step '${step.name}' failed`);
+            }
+            // Check if workflow was paused (e.g., by waitForEvent)
+            // Note: State can change during async step execution
+            if (this._state === 'paused') {
+                return;
+            }
+            this._currentStepIndex++;
+            await this.persistState();
+        }
+    }
+    async executeStep(step, index) {
+        // Handle parallel step execution
+        if (step.isParallel && step.parallelSteps) {
+            return this.executeParallelStep(step, index);
+        }
+        const result = {
+            name: step.name,
+            status: 'running',
+            startedAt: new Date(),
+        };
+        this.emit('step.started', {
+            instanceId: this._instanceId,
+            stepName: step.name,
+            stepIndex: index,
+        });
+        // Create modifier context for input/output transformation
+        const modifierContext = {
+            stepName: step.name,
+            stepIndex: index,
+            workflowInstanceId: this._instanceId,
+        };
+        const maxRetries = step.config?.retries || 0;
+        const modifiers = step.config?.modifiers || [];
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            result.retryCount = attempt;
+            try {
+                // Apply input modifiers before step execution
+                const modifiedInput = modifiers.length > 0
+                    ? await applyInputModifiers(modifiers, this._input, modifierContext)
+                    : this._input;
+                // Create context with potentially modified input
+                const context = this.createStepContext(step.name, index, modifiedInput);
+                // Handle timeout if configured
+                let output;
+                if (step.config?.timeout) {
+                    const timeoutMs = parseDuration(step.config.timeout);
+                    output = await Promise.race([
+                        step.handler(context),
+                        new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new WorkflowTimeoutError(timeoutMs, step.name));
+                            }, timeoutMs);
+                        }),
+                    ]);
+                }
+                else {
+                    output = await step.handler(context);
+                }
+                // Check if we were paused during execution (e.g., waitForEvent)
+                if (this._state === 'paused') {
+                    result.status = 'running'; // Still running, just paused
+                    return result;
+                }
+                // Apply output modifiers after step execution
+                const modifiedOutput = modifiers.length > 0
+                    ? await applyOutputModifiers(modifiers, output, modifiedInput, modifierContext)
+                    : output;
+                result.status = 'completed';
+                result.output = modifiedOutput;
+                result.completedAt = new Date();
+                result.duration = result.completedAt.getTime() - result.startedAt.getTime();
+                this.emit('step.completed', {
+                    instanceId: this._instanceId,
+                    stepName: step.name,
+                    stepIndex: index,
+                    output: modifiedOutput,
+                    duration: result.duration,
+                });
+                return result;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // Check if it's a timeout error or if we should retry
+                if (error instanceof WorkflowTimeoutError || attempt >= maxRetries) {
+                    break;
+                }
+                // Wait before retrying
+                if (step.config?.retryDelay) {
+                    const delayMs = parseDuration(step.config.retryDelay);
+                    await new Promise((resolve) => setTimeout(resolve, delayMs));
+                }
+            }
+        }
+        result.status = 'failed';
+        result.error = new WorkflowStepError(step.name, index, lastError);
+        result.completedAt = new Date();
+        result.duration = result.completedAt.getTime() - result.startedAt.getTime();
+        this.emit('step.failed', {
+            instanceId: this._instanceId,
+            stepName: step.name,
+            stepIndex: index,
+            error: { message: result.error.message, name: result.error.name },
+        });
+        return result;
+    }
+    /**
+     * Execute a parallel step group
+     */
+    async executeParallelStep(step, index) {
+        const result = {
+            name: step.name,
+            status: 'running',
+            startedAt: new Date(),
+            parallelResults: {},
+        };
+        const options = step.parallelOptions || {};
+        // Emit parallel.started event
+        this.emit('parallel.started', {
+            instanceId: this._instanceId,
+            groupName: step.name,
+            stepCount: step.parallelSteps.length,
+        });
+        // Create base context for all parallel steps
+        const previousOutput = index > 0 ? this._stepResults[index - 1]?.output : undefined;
+        const baseContext = {
+            input: this._input,
+            previousStepOutput: previousOutput,
+            workflowInstanceId: this._instanceId,
+            waitForEvent: this.createWaitForEvent(step.name),
+            $: this.createDomainProxy(),
+            emit: (event, data) => this.emit(event, data),
+        };
+        // Create executor
+        const executor = new ParallelStepExecutor(step.parallelSteps, options);
+        try {
+            // Execute all parallel steps
+            const parallelResult = await executor.execute(baseContext, 
+            // onStepStart callback
+            (stepName) => {
+                this.emit('step.started', {
+                    instanceId: this._instanceId,
+                    stepName,
+                    stepIndex: index,
+                    isParallel: true,
+                    groupName: step.name,
+                });
+            }, 
+            // onStepComplete callback
+            (stepName, stepResult) => {
+                result.parallelResults[stepName] = stepResult;
+                // Persist individual parallel step result
+                this.storage.put(`workflow:parallel:${index}:${stepName}`, {
+                    name: stepResult.name,
+                    status: stepResult.status,
+                    output: stepResult.output,
+                    duration: stepResult.duration,
+                    startedAt: stepResult.startedAt?.toISOString(),
+                    completedAt: stepResult.completedAt?.toISOString(),
+                    error: stepResult.error
+                        ? {
+                            message: stepResult.error.message,
+                            name: stepResult.error.name,
+                        }
+                        : undefined,
+                });
+                if (stepResult.status === 'completed') {
+                    this.emit('step.completed', {
+                        instanceId: this._instanceId,
+                        stepName,
+                        stepIndex: index,
+                        output: stepResult.output,
+                        duration: stepResult.duration,
+                        isParallel: true,
+                        groupName: step.name,
+                    });
+                }
+                else if (stepResult.status === 'failed') {
+                    this.emit('step.failed', {
+                        instanceId: this._instanceId,
+                        stepName,
+                        stepIndex: index,
+                        error: stepResult.error
+                            ? { message: stepResult.error.message, name: stepResult.error.name }
+                            : undefined,
+                        isParallel: true,
+                        groupName: step.name,
+                    });
+                }
+            });
+            result.status = 'completed';
+            result.output = parallelResult.merged;
+            result.parallelResults = parallelResult.results;
+            result.completedAt = new Date();
+            result.duration = result.completedAt.getTime() - result.startedAt.getTime();
+            // Emit parallel.completed event
+            this.emit('parallel.completed', {
+                instanceId: this._instanceId,
+                groupName: step.name,
+                completedCount: parallelResult.completedCount,
+                failedCount: parallelResult.failedCount,
+                duration: parallelResult.duration,
+            });
+            // Also emit step.completed for the parallel group itself
+            this.emit('step.completed', {
+                instanceId: this._instanceId,
+                stepName: step.name,
+                stepIndex: index,
+                output: result.output,
+                duration: result.duration,
+            });
+            return result;
+        }
+        catch (error) {
+            // Capture partial results from executor
+            const partialResults = executor.getResults();
+            for (const [name, stepResult] of partialResults) {
+                result.parallelResults[name] = stepResult;
+            }
+            result.status = 'failed';
+            result.error = error instanceof Error ? error : new Error(String(error));
+            result.completedAt = new Date();
+            result.duration = result.completedAt.getTime() - result.startedAt.getTime();
+            // Emit parallel.failed event
+            const failedStep = error instanceof ParallelExecutionError ? error.failedStep : 'unknown';
+            this.emit('parallel.failed', {
+                instanceId: this._instanceId,
+                groupName: step.name,
+                failedStep,
+                error: result.error
+                    ? { message: result.error.message, name: result.error.name }
+                    : undefined,
+            });
+            this.emit('step.failed', {
+                instanceId: this._instanceId,
+                stepName: step.name,
+                stepIndex: index,
+                error: result.error
+                    ? { message: result.error.message, name: result.error.name }
+                    : undefined,
+            });
+            return result;
+        }
+    }
+    createStepContext(stepName, stepIndex, inputOverride) {
+        const previousOutput = stepIndex > 0 ? this._stepResults[stepIndex - 1]?.output : undefined;
+        return {
+            input: inputOverride !== undefined ? inputOverride : this._input,
+            previousStepOutput: previousOutput,
+            stepName,
+            stepIndex,
+            workflowInstanceId: this._instanceId,
+            waitForEvent: this.createWaitForEvent(stepName),
+            $: this.createDomainProxy(),
+            emit: (event, data) => this.emit(event, data),
+        };
+    }
+    createWaitForEvent(stepName) {
+        return async (eventName, options = {}) => {
+            // Track pending event
+            this._pendingEvents.push(eventName);
+            // Pause the workflow
+            this._state = 'paused';
+            await this.persistState();
+            // Register the wait
+            const waitId = await this.waitForEventManager.registerWait(eventName, options);
+            return new Promise((resolve, reject) => {
+                this.waitResolvers.set(waitId, {
+                    resolve: resolve,
+                    reject,
+                });
+                // Handle timeout
+                if (options.timeout) {
+                    const timeoutMs = parseDuration(options.timeout);
+                    setTimeout(async () => {
+                        if (this.waitResolvers.has(waitId)) {
+                            this.waitResolvers.delete(waitId);
+                            this._pendingEvents = this._pendingEvents.filter((e) => e !== eventName);
+                            await this.waitForEventManager.cancelWait(waitId);
+                            reject(new WorkflowTimeoutError(timeoutMs, stepName));
+                        }
+                    }, timeoutMs);
+                }
+            });
+        };
+    }
+    createDomainProxy() {
+        if (this._options.domainProxy) {
+            return this._options.domainProxy;
+        }
+        // Default empty proxy
+        return new Proxy({}, {
+            get: (_, noun) => {
+                return (id) => {
+                    return new Proxy({}, {
+                        get: (_, method) => {
+                            return async (...args) => {
+                                throw new Error(`Domain proxy not configured: $.${noun}('${id}').${method}()`);
+                            };
+                        },
+                    });
+                };
+            },
+        });
+    }
+    // ==========================================================================
+    // EVENT DELIVERY
+    // ==========================================================================
+    async deliverEvent(eventName, payload) {
+        // Find matching wait
+        const waits = await this.waitForEventManager.listPendingWaits();
+        const matchingWait = waits.find((w) => w.eventName === eventName);
+        if (!matchingWait) {
+            return;
+        }
+        // Resolve the wait
+        const result = await this.waitForEventManager.deliverEvent(matchingWait.id, eventName, payload);
+        if (result.resolved) {
+            // Remove from pending events
+            this._pendingEvents = this._pendingEvents.filter((e) => e !== eventName);
+            // Resolve the promise
+            const resolver = this.waitResolvers.get(matchingWait.id);
+            if (resolver) {
+                resolver.resolve(payload);
+                this.waitResolvers.delete(matchingWait.id);
+            }
+            // Resume workflow if no more pending waits
+            if (this._pendingEvents.length === 0 && this._state === 'paused') {
+                this._state = 'running';
+                await this.persistState();
+                // Continue execution
+                this._currentStepIndex++;
+                await this.executeSteps();
+                if (this._state === 'running') {
+                    this._state = 'completed';
+                    this._completedAt = new Date();
+                    this._output = this._stepResults[this._stepResults.length - 1]?.output;
+                    await this.persistState();
+                    this.emit('workflow.completed', {
+                        instanceId: this._instanceId,
+                        output: this._output,
+                        duration: this.duration,
+                    });
+                }
+            }
+        }
+    }
+    async handleAlarm() {
+        await this.waitForEventManager.handleAlarm();
+    }
+    // ==========================================================================
+    // EVENT EMITTER
+    // ==========================================================================
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+    }
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    emit(event, data) {
+        this.eventHandlers.get(event)?.forEach((handler) => {
+            try {
+                handler(data);
+            }
+            catch (e) {
+                console.error(`Error in event handler for ${event}:`, e);
+            }
+        });
+    }
+    // ==========================================================================
+    // PERSISTENCE
+    // ==========================================================================
+    async persistState() {
+        const state = {
+            status: this._state,
+            currentStepIndex: this._currentStepIndex,
+            input: this._input,
+            output: this._output,
+            pendingEvents: [...this._pendingEvents],
+            startedAt: this._startedAt?.toISOString(),
+            completedAt: this._completedAt?.toISOString(),
+        };
+        if (this._error) {
+            state.error = {
+                message: this._error.message,
+                name: this._error.name,
+                stack: this._error.stack,
+            };
+        }
+        await this.storage.put('workflow:state', state);
+    }
+    // ==========================================================================
+    // METRICS
+    // ==========================================================================
+    getMetrics() {
+        return {
+            totalSteps: this._steps.length,
+            completedSteps: this._stepResults.filter((r) => r.status === 'completed').length,
+            failedSteps: this._stepResults.filter((r) => r.status === 'failed').length,
+            duration: this.duration,
+        };
+    }
+}
+export default WorkflowRuntime;
+//# sourceMappingURL=WorkflowRuntime.js.map