@ductape/sdk 0.1.8 → 0.1.10

package/dist/workflows/workflow-executor.js

@@ -0,0 +1,2467 @@
+"use strict";
+/**
+ * WorkflowExecutor - Executes workflow steps and manages rollbacks
+ *
+ * Handles the actual execution of workflow steps, including:
+ * - Processing each step type (action, database, notification, etc.)
+ * - Managing rollback on failure
+ * - Tracking workflow state and completed steps
+ * - Handling signals and checkpoints
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecutor = void 0;
+const crypto_1 = require("crypto");
+const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
+const products_service_1 = __importDefault(require("../products/services/products.service"));
+const processorApi_service_1 = require("../api/services/processorApi.service");
+const workflowApi_service_1 = require("../api/services/workflowApi.service");
+const graph_1 = require("../graph");
+const database_1 = require("../database");
+const brokers_1 = require("../brokers");
+const storage_1 = require("../storage");
+const vector_1 = require("../vector");
+const resilience_1 = require("../resilience");
+const logs_service_1 = __importDefault(require("../logs/logs.service"));
+const logs_types_1 = require("../logs/logs.types");
+const types_1 = require("../types");
+const inputs_types_1 = require("../types/inputs.types");
+const processor_utils_1 = require("../processor/utils/processor.utils");
+const productsBuilder_types_1 = require("../types/productsBuilder.types");
+const date_fns_1 = require("date-fns");
+/** Only log when DUCTAPE_DEBUG is set to avoid sync I/O and serialization cost in hot path */
+const debugLog = typeof process !== 'undefined' && (((_a = process.env) === null || _a === void 0 ? void 0 : _a.DUCTAPE_DEBUG) === 'true' || ((_b = process.env) === null || _b === void 0 ? void 0 : _b.DUCTAPE_DEBUG) === '1')
+    ? (...args) => console.log(...args)
+    : () => { };
+/** Always-on step/summary logging for visibility in tests and support */
+const stepLog = typeof process !== 'undefined'
+    ? (msg, data) => {
+        if (data != null && Object.keys(data).length > 0) {
+            console.log(`[WorkflowExecutor] ${msg}`, data);
+        }
+        else {
+            console.log(`[WorkflowExecutor] ${msg}`);
+        }
+    }
+    : () => { };
+/** Normalize error to a string and extract HTTP details when present (e.g. Axios) */
+function formatErrorDetails(error) {
+    var _a, _b, _c, _d;
+    const err = error;
+    const message = (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : String(error);
+    const out = { message };
+    if (err === null || err === void 0 ? void 0 : err.stack)
+        out.stack = err.stack;
+    if (err === null || err === void 0 ? void 0 : err.response) {
+        out.status = (_b = err.response) === null || _b === void 0 ? void 0 : _b.status;
+        const data = (_c = err.response) === null || _c === void 0 ? void 0 : _c.data;
+        out.responseBody = data;
+        // Prefer API error reason over generic "Request failed with status code N"
+        const apiErrors = data === null || data === void 0 ? void 0 : data.errors;
+        if (apiErrors != null) {
+            out.reason = typeof apiErrors === 'string' ? apiErrors : ((_d = apiErrors === null || apiErrors === void 0 ? void 0 : apiErrors.message) !== null && _d !== void 0 ? _d : JSON.stringify(apiErrors));
+        }
+    }
+    return out;
+}
+/**
+ * WorkflowExecutor handles the execution of workflow steps
+ */
+class WorkflowExecutor {
+    constructor(config, workflow, options, private_key, sessionLogFields, preInitializedBuilder) {
+        var _a, _b;
+        this._processorService = null;
+        this._graphService = null;
+        this._databaseService = null;
+        this._brokersService = null;
+        this._storageService = null;
+        this._vectorService = null;
+        this._quotaService = null;
+        this._fallbackService = null;
+        this.productId = null;
+        /** Pending signals waiting to be resolved */
+        this.pendingSignals = new Map();
+        /** Signal polling interval (ms) */
+        this.signalPollInterval = 2000;
+        /** Signal polling timer */
+        this.signalPollTimer = null;
+        /** Session log fields for logging */
+        this.sessionLogFields = {};
+        /** LogService instance for logging operations */
+        this.logService = null;
+        /** Base log fields inherited by all step logs */
+        this.baseLogs = null;
+        /** Set when a graph step runs; we disconnect once at end of execute() instead of per-step. */
+        this.graphConnectionUsed = false;
+        /** Pre-fetched bootstrap data per step tag (workflow batch prefetch). */
+        this.stepBootstrapCache = new Map();
+        debugLog('[WorkflowExecutor] constructor ENTRY', {
+            workflow_tag: workflow.tag,
+            product: options.product,
+            env: options.env,
+            hasSessionFields: !!sessionLogFields && Object.keys(sessionLogFields).length > 0,
+        });
+        this.config = config;
+        this.workflow = workflow;
+        this.sessionLogFields = sessionLogFields || {};
+        this._privateKey = private_key || '';
+        this.preInitializedProduct = Boolean(preInitializedBuilder);
+        // Use pre-initialized builder from WorkflowService when provided to avoid duplicate initProduct API call
+        this.productBuilder = preInitializedBuilder !== null && preInitializedBuilder !== void 0 ? preInitializedBuilder : new products_service_1.default({
+            workspace_id: config.workspace_id,
+            public_key: config.public_key,
+            user_id: config.user_id,
+            token: config.token,
+            env_type: config.env_type,
+            access_key: config.access_key,
+            workspace_private_key: this._privateKey || undefined,
+        });
+        // Lightweight API services (created up front)
+        this.processorApiService = new processorApi_service_1.ProcessorApiService(config.env_type);
+        this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
+        // Heavy services are lazy-initialized on first use (getProcessorService, getGraphService, etc.)
+        // Initialize workflow state
+        this.state = {
+            workflow_id: (0, crypto_1.randomUUID)(),
+            workflow_tag: workflow.tag,
+            product: options.product,
+            env: options.env,
+            input: options.input,
+            steps: {},
+            completed_steps: [],
+            step_timings: [],
+            state: {},
+            status: types_1.WorkflowStatus.PENDING,
+            started_at: Date.now(),
+        };
+        debugLog('[WorkflowExecutor] constructor DONE', {
+            workflow_id: this.state.workflow_id,
+            workflow_tag: this.state.workflow_tag,
+            steps_count: (_b = (_a = workflow.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+        });
+    }
+    /**
+     * Get auth payload for API calls
+     */
+    getAuthPayload() {
+        return {
+            user_id: this.config.user_id,
+            workspace_id: this.config.workspace_id,
+            public_key: this.config.public_key,
+            token: this.config.token,
+        };
+    }
+    /** Product private key for processor result encryption; must always match backend decryption key. No fallback to workspace key. */
+    getProcessorResultEncryptionKey() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.productBuilder) === null || _a === void 0 ? void 0 : _a.fetchPrivateKey) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : '';
+    }
+    /** Lazy-initialized processor (shares productBuilder to avoid duplicate product init per step). */
+    getProcessorService() {
+        if (!this._processorService) {
+            this._processorService = new processor_service_1.default({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                private_key: this._privateKey,
+                access_key: this.config.access_key,
+                preInitializedProductBuilder: this.productBuilder,
+            });
+        }
+        return this._processorService;
+    }
+    /** Lazy-initialized graph service. */
+    getGraphService() {
+        if (!this._graphService) {
+            this._graphService = new graph_1.GraphService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                private_key: this._privateKey,
+                access_key: this.config.access_key,
+            });
+        }
+        return this._graphService;
+    }
+    /** Lazy-initialized database service. */
+    getDatabaseService() {
+        if (!this._databaseService) {
+            this._databaseService = new database_1.DatabaseService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                private_key: this._privateKey,
+                access_key: this.config.access_key,
+            });
+        }
+        return this._databaseService;
+    }
+    /** Lazy-initialized brokers service. Used for produce steps so ctx.messaging.produce uses the same path as ductape.messaging.produce (pool, tracking, cache). */
+    getBrokersService() {
+        if (!this._brokersService) {
+            this._brokersService = new brokers_1.BrokersService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                access_key: this.config.access_key,
+                redis_client: this.config.redis_client,
+                preInitializedProductBuilder: this.productBuilder,
+            });
+        }
+        return this._brokersService;
+    }
+    /** Lazy-initialized storage service. Used for storage steps (upload/download/delete) instead of processor. */
+    getStorageService() {
+        if (!this._storageService) {
+            this._storageService = new storage_1.StorageService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                redis_client: this.config.redis_client,
+                private_key: this._privateKey,
+            });
+        }
+        return this._storageService;
+    }
+    /** Lazy-initialized vector service. Used for vector steps (query/upsert/delete/execute action). */
+    getVectorService() {
+        if (!this._vectorService) {
+            this._vectorService = new vector_1.VectorDatabaseService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                redis_client: this.config.redis_client,
+                private_key: this._privateKey,
+                access_key: this.config.access_key,
+            });
+        }
+        return this._vectorService;
+    }
+    /** Lazy-initialized quota service. */
+    getQuotaService() {
+        if (!this._quotaService) {
+            this._quotaService = new resilience_1.QuotaService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                private_key: this._privateKey,
+            });
+        }
+        return this._quotaService;
+    }
+    /** Lazy-initialized fallback service. */
+    getFallbackService() {
+        if (!this._fallbackService) {
+            this._fallbackService = new resilience_1.FallbackService({
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                private_key: this._privateKey,
+            });
+        }
+        return this._fallbackService;
+    }
+    /**
+     * Persist workflow execution result to backend
+     */
+    async persistExecutionResult(status, output, error) {
+        debugLog('[WorkflowExecutor] persistExecutionResult ENTRY', {
+            workflow_id: this.state.workflow_id,
+            workflow_tag: this.state.workflow_tag,
+            status,
+            hasError: !!error,
+        });
+        try {
+            const resultData = {
+                workflow_tag: this.state.workflow_tag,
+                input: this.state.input,
+                output,
+                completed_steps: this.state.completed_steps,
+                failed_step: this.state.failed_step,
+                step_outputs: this.state.steps,
+                error,
+            };
+            const inputPayload = { product: this.state.product, env: this.state.env, event: this.state.workflow_tag, input: this.state.input };
+            const resultStr = JSON.stringify(resultData);
+            const inputStr = JSON.stringify(inputPayload);
+            const encKey = this.getProcessorResultEncryptionKey();
+            const processorResult = {
+                process_id: this.state.workflow_id,
+                product_id: this.productId || null,
+                env: this.state.env,
+                component: types_1.LogEventTypes.WORKFLOW,
+                status,
+                start: this.state.started_at,
+                end: Date.now(),
+                retryable: true,
+                result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr,
+                feature_id: undefined,
+                input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr,
+                workflow_id: this.state.workflow_id,
+                workflow_tag: this.state.workflow_tag,
+                product_tag: this.state.product,
+                workspace_id: this.config.workspace_id,
+            };
+            await this.processorApiService.saveResult(processorResult, this.getAuthPayload());
+            debugLog('[WorkflowExecutor] persistExecutionResult SUCCESS', { workflow_id: this.state.workflow_id, status });
+        }
+        catch (err) {
+            // Log error but don't throw - persistence failure shouldn't fail the workflow
+            debugLog('[WorkflowExecutor] persistExecutionResult FAILED', { workflow_id: this.state.workflow_id, status, error: err });
+        }
+    }
+    /**
+     * Step processor results must always use component: 'workflow_step'.
+     * step_type is the step kind: action, notification, storage, produce, database_action, graph, vector, quota, fallback, child_workflow, sleep, wait_for_signal, checkpoint, feature.
+     */
+    getStepTypeForResult(step) {
+        var _a;
+        if (step.type === types_1.WorkflowStepType.PUBLISH)
+            return 'produce';
+        return (_a = step.type) !== null && _a !== void 0 ? _a : 'action';
+    }
+    /**
+     * Persist individual step execution to backend (input/output per step in processor result).
+     * Processor results for steps always have component: 'workflow_step' and step_type set to the step kind.
+     */
+    async persistStepResult(step, status, output, error, duration, input) {
+        const resolvedInput = input !== null && input !== void 0 ? input : step.input;
+        const stepType = this.getStepTypeForResult(step);
+        debugLog('[WorkflowExecutor] persistStepResult ENTRY', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            step_type: stepType,
+            status,
+            durationMs: duration,
+        });
+        try {
+            // Caller passes the step return value (resolved shape) on success; we persist it as-is
+            const stepProcessId = `${this.state.workflow_id}:${step.tag}`;
+            const value = status === types_1.LogEventStatus.SUCCESS
+                ? output !== undefined && output !== null
+                    ? output
+                    : {}
+                : { error: error !== null && error !== void 0 ? error : 'Step failed' };
+            const resultStr = JSON.stringify(value);
+            const inputStr = JSON.stringify(resolvedInput);
+            const encKey = this.getProcessorResultEncryptionKey();
+            const stepResult = {
+                process_id: stepProcessId,
+                product_id: this.productId || null,
+                env: this.state.env,
+                component: types_1.LogEventTypes.WORKFLOW_STEP, // step results always workflow_step
+                status,
+                start: Date.now() - (duration || 0),
+                end: Date.now(),
+                retryable: true,
+                result: encKey ? (0, processor_utils_1.encrypt)(resultStr, encKey) : resultStr,
+                feature_id: undefined,
+                input: encKey ? (0, processor_utils_1.encrypt)(inputStr, encKey) : inputStr,
+                workflow_id: this.state.workflow_id,
+                workflow_tag: this.state.workflow_tag,
+                product_tag: this.state.product,
+                workspace_id: this.config.workspace_id,
+                step_tag: step.tag,
+                step_type: stepType, // action | notification | storage | produce | database_action | graph | vector | quota | fallback | child_workflow | sleep | wait_for_signal | checkpoint | feature
+                step_error: error,
+                step_duration_ms: duration,
+            };
+            this.processorApiService.saveResult(stepResult, this.getAuthPayload()).then(() => debugLog('[WorkflowExecutor] persistStepResult SUCCESS', { workflow_id: this.state.workflow_id, step_tag: step.tag }), (err) => debugLog('[WorkflowExecutor] persistStepResult FAILED', { workflow_id: this.state.workflow_id, step_tag: step.tag, error: err }));
+        }
+        catch (err) {
+            debugLog('[WorkflowExecutor] persistStepResult ENTRY FAILED', { workflow_id: this.state.workflow_id, step_tag: step.tag, error: err });
+        }
+    }
+    /**
+     * Initialize logging service and base log fields
+     */
+    initializeLogging() {
+        var _a;
+        if (!this.logService && this.productId) {
+            this.logService = new logs_service_1.default({
+                product_id: this.productId,
+                workspace_id: this.config.workspace_id,
+                public_key: this.config.public_key,
+                user_id: this.config.user_id,
+                token: this.config.token,
+                env_type: this.config.env_type,
+                workspace_private_key: (_a = this._privateKey) !== null && _a !== void 0 ? _a : undefined,
+            });
+            // Set up base logs that all step logs inherit
+            this.baseLogs = Object.assign({ product_tag: this.state.product, workspace_id: this.config.workspace_id, env: this.state.env, process_id: this.state.workflow_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: this.state.workflow_tag }, this.sessionLogFields);
+        }
+    }
+    /**
+     * Log a step execution event
+     */
+    logStepEvent(step, message, status, additionalData) {
+        if (!this.logService || !this.baseLogs)
+            return;
+        const stepTypeDisplay = step.type === types_1.WorkflowStepType.PUBLISH ? 'produce' : step.type;
+        const stepProcessId = `${this.state.workflow_id}:${step.tag}`;
+        this.logService.add(Object.assign(Object.assign({}, this.baseLogs), { process_id: stepProcessId, type: logs_types_1.LogEventTypes.WORKFLOW_STEP, child_tag: step.tag, message,
+            status, data: Object.assign({ workflow: this.state.workflow_tag, workflow_id: this.state.workflow_id, step: step.tag, step_type: stepTypeDisplay }, additionalData) }));
+    }
+    /**
+     * Execute the workflow
+     */
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const startTime = Date.now();
+        debugLog('[WorkflowExecutor] execute ENTRY', {
+            workflow_id: this.state.workflow_id,
+            workflow_tag: this.state.workflow_tag,
+            product: this.state.product,
+            env: this.state.env,
+        });
+        try {
+            // Track phase so failures before first step are reported as (initialization)
+            this.state.current_step = '(initialization)';
+            // Skip product init when builder was pre-initialized by WorkflowService (avoids duplicate initProduct API call)
+            if (this.preInitializedProduct) {
+                this.productId = this.productBuilder.fetchProductId();
+            }
+            else {
+                await this.productBuilder.initializeProductByTag(this.state.product);
+                this.productId = this.productBuilder.fetchProductId();
+            }
+            debugLog('[WorkflowExecutor] execute product initialized', { workflow_id: this.state.workflow_id, product_id: this.productId });
+            // Initialize logging after we have product ID
+            this.initializeLogging();
+            this.state.status = types_1.WorkflowStatus.RUNNING;
+            // Get steps in execution order (respecting dependencies)
+            const orderedSteps = this.getOrderedSteps();
+            stepLog('Ordered steps', {
+                count: orderedSteps.length,
+                steps: orderedSteps.map((s) => ({ tag: s.tag, type: s.type === types_1.WorkflowStepType.PUBLISH ? 'produce' : s.type })),
+            });
+            debugLog('[WorkflowExecutor] execute ordered steps', {
+                workflow_id: this.state.workflow_id,
+                steps_count: orderedSteps.length,
+                step_tags: orderedSteps.map((s) => s.tag),
+            });
+            // Pre-fetch all action/notification/storage bootstrap data in one backend call (cached for step executors)
+            try {
+                await this.prefetchStepBootstrap(orderedSteps);
+            }
+            catch (prefetchErr) {
+                stepLog('Bootstrap prefetch failed (continuing without prefetch)', {
+                    error: (_a = prefetchErr === null || prefetchErr === void 0 ? void 0 : prefetchErr.message) !== null && _a !== void 0 ? _a : String(prefetchErr),
+                });
+                this.stepBootstrapCache.clear();
+            }
+            // Execute each step
+            for (const step of orderedSteps) {
+                // Check step condition if present
+                if (step.condition && !(await this.evaluateCondition(step.condition))) {
+                    debugLog('[WorkflowExecutor] execute step SKIPPED (condition)', { workflow_id: this.state.workflow_id, step_tag: step.tag });
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (condition not met)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue; // Skip step if condition not met
+                }
+                this.state.current_step = step.tag;
+                stepLog('Step start', { tag: step.tag, type: step.type === types_1.WorkflowStepType.PUBLISH ? 'produce' : step.type });
+                debugLog('[WorkflowExecutor] execute step START', { workflow_id: this.state.workflow_id, step_tag: step.tag, step_type: step.type });
+                // Log step start
+                this.logStepEvent(step, `Step ${step.tag} - started`, logs_types_1.LogEventStatus.PROCESSING);
+                const result = await this.executeStep(step);
+                stepLog('Step end', Object.assign({ tag: step.tag, type: step.type === types_1.WorkflowStepType.PUBLISH ? 'produce' : step.type, success: result.success, duration_ms: result.duration }, (result.error && { error: result.error })));
+                if (result.error) {
+                    console.warn(`[WorkflowExecutor] Step "${step.tag}" error:`, result.error);
+                }
+                debugLog('[WorkflowExecutor] execute step END', {
+                    workflow_id: this.state.workflow_id,
+                    step_tag: step.tag,
+                    success: result.success,
+                    durationMs: result.duration,
+                    hasError: !!result.error,
+                    input: result.input,
+                    output: result.output,
+                });
+                // Log step completion
+                this.logStepEvent(step, result.success ? `Step ${step.tag} - completed` : `Step ${step.tag} - failed`, result.success ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, { duration: result.duration, error: result.error });
+                // Step return value = resolved step.output schema with primitive result, or raw when no schema
+                const outputSchema = step.output;
+                const hasOutputSchema = outputSchema && typeof outputSchema === 'object' && !Array.isArray(outputSchema) && Object.keys(outputSchema).length > 0;
+                let stepReturnValue = result.output;
+                if (result.success && hasOutputSchema) {
+                    try {
+                        stepReturnValue = await this.resolveInput(outputSchema, result.output);
+                    }
+                    catch (_p) {
+                        stepReturnValue = result.output;
+                    }
+                }
+                else if (!result.success) {
+                    stepReturnValue = undefined;
+                }
+                console.warn(`[WorkflowExecutor] Step "${step.tag}" output:`, stepReturnValue);
+                // Persist step result to backend (use step return shape, not raw primitive)
+                await this.persistStepResult(step, result.success ? types_1.LogEventStatus.SUCCESS : types_1.LogEventStatus.FAIL, stepReturnValue, result.error, result.duration, result.input);
+                this.state.step_timings.push({
+                    tag: step.tag,
+                    duration_ms: result.duration,
+                    success: result.success,
+                });
+                if (!result.success) {
+                    this.state.failed_step = step.tag;
+                    stepLog('Step failed', { tag: step.tag, error: result.error, allow_fail: (_b = step.options) === null || _b === void 0 ? void 0 : _b.allow_fail, optional: (_c = step.options) === null || _c === void 0 ? void 0 : _c.optional });
+                    debugLog('[WorkflowExecutor] execute step FAILED', {
+                        workflow_id: this.state.workflow_id,
+                        step_tag: step.tag,
+                        error: result.error,
+                        allow_fail: (_d = step.options) === null || _d === void 0 ? void 0 : _d.allow_fail,
+                        optional: (_e = step.options) === null || _e === void 0 ? void 0 : _e.optional,
+                    });
+                    // Check if step allows failure
+                    if ((_f = step.options) === null || _f === void 0 ? void 0 : _f.allow_fail) {
+                        // Store error but continue
+                        this.state.steps[step.tag] = { error: result.error };
+                        continue;
+                    }
+                    // Check if step is optional
+                    if ((_g = step.options) === null || _g === void 0 ? void 0 : _g.optional) {
+                        // Don't trigger rollback, just continue
+                        continue;
+                    }
+                    // Trigger rollback
+                    this.state.status = types_1.WorkflowStatus.ROLLING_BACK;
+                    debugLog('[WorkflowExecutor] execute ROLLBACK START', { workflow_id: this.state.workflow_id, failed_step: step.tag, reason: result.error });
+                    const rollbackResult = await this.executeRollback(step.tag, result.error || 'Step failed');
+                    debugLog('[WorkflowExecutor] execute ROLLBACK END', {
+                        workflow_id: this.state.workflow_id,
+                        success: rollbackResult.success,
+                        rolled_back_steps: rollbackResult.rolled_back_steps,
+                        failed_rollbacks: (_j = (_h = rollbackResult.failed_steps) === null || _h === void 0 ? void 0 : _h.length) !== null && _j !== void 0 ? _j : 0,
+                    });
+                    // Persist failed workflow result
+                    await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, result.error);
+                    stepLog('Run finished (rollback)', {
+                        status: types_1.WorkflowStatus.ROLLED_BACK,
+                        failed_step: step.tag,
+                        error: result.error,
+                        completed_steps: this.state.completed_steps,
+                        step_timings: this.state.step_timings,
+                    });
+                    await ((_k = this.logService) === null || _k === void 0 ? void 0 : _k.publish());
+                    if (this.graphConnectionUsed) {
+                        await this.getGraphService().disconnect().catch(() => { });
+                        await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                        if (this._brokersService)
+                            await this._brokersService.disconnectAll().catch(() => { });
+                        await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                        await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                        await this.getProcessorService().disconnectSmsClients().catch(() => { });
+                    }
+                    return {
+                        status: types_1.WorkflowStatus.ROLLED_BACK,
+                        workflow_id: this.state.workflow_id,
+                        error: result.error,
+                        execution_time: Date.now() - startTime,
+                        completed_steps: this.state.completed_steps,
+                        step_timings: this.state.step_timings,
+                        failed_step: step.tag,
+                        rollback_info: {
+                            triggered_by: step.tag,
+                            reason: result.error || 'Step failed',
+                            rolled_back_steps: rollbackResult.rolled_back_steps,
+                            failed_rollbacks: rollbackResult.failed_steps,
+                        },
+                    };
+                }
+                // Store step return shape in state (same value we persisted)
+                this.state.steps[step.tag] = stepReturnValue;
+                this.state.completed_steps.push(step.tag);
+            }
+            this.state.status = types_1.WorkflowStatus.COMPLETED;
+            this.state.ended_at = Date.now();
+            // Determine output - use last step output or aggregate (resolves $ operators)
+            const output = await this.determineWorkflowOutput();
+            stepLog('Run finished (completed)', {
+                status: types_1.WorkflowStatus.COMPLETED,
+                completed_steps: this.state.completed_steps,
+                step_timings: this.state.step_timings,
+                execution_time_ms: Date.now() - startTime,
+            });
+            debugLog('[WorkflowExecutor] execute COMPLETED', {
+                workflow_id: this.state.workflow_id,
+                workflow_tag: this.state.workflow_tag,
+                completed_steps: this.state.completed_steps.length,
+                execution_time_ms: Date.now() - startTime,
+            });
+            // Persist successful workflow result
+            await this.persistExecutionResult(types_1.LogEventStatus.SUCCESS, output);
+            // Fire-and-forget log publish on success so we don't block on log upload
+            (_l = this.logService) === null || _l === void 0 ? void 0 : _l.publish().catch(() => { });
+            if (this.graphConnectionUsed) {
+                await this.getGraphService().disconnect().catch(() => { });
+                await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                if (this._brokersService)
+                    await this._brokersService.disconnectAll().catch(() => { });
+                await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                await this.getProcessorService().disconnectSmsClients().catch(() => { });
+            }
+            return {
+                status: types_1.WorkflowStatus.COMPLETED,
+                workflow_id: this.state.workflow_id,
+                output: output,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                step_timings: this.state.step_timings,
+            };
+        }
+        catch (error) {
+            this.state.status = types_1.WorkflowStatus.FAILED;
+            this.state.ended_at = Date.now();
+            const details = formatErrorDetails(error);
+            const failedAt = (_m = this.state.current_step) !== null && _m !== void 0 ? _m : '(unknown)';
+            debugLog('[WorkflowExecutor] execute FAILED (exception)', Object.assign(Object.assign({ workflow_id: this.state.workflow_id, workflow_tag: this.state.workflow_tag, failed_at: failedAt, completed_steps: this.state.completed_steps, error: details.message }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: details.responseBody })));
+            if (details.stack) {
+                debugLog('[WorkflowExecutor] execute FAILED stack', details.stack);
+            }
+            // Persist failed workflow result with clear failure reason
+            const errorSummary = details.status != null
+                ? `Failed at ${failedAt}: ${details.message} (HTTP ${details.status})`
+                : `Failed at ${failedAt}: ${details.message}`;
+            stepLog('Run finished (failed - exception)', Object.assign({ status: types_1.WorkflowStatus.FAILED, failed_step: failedAt, error: errorSummary, completed_steps: this.state.completed_steps, step_timings: this.state.step_timings }, (details.reason && { reason: details.reason })));
+            await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, errorSummary);
+            await ((_o = this.logService) === null || _o === void 0 ? void 0 : _o.publish());
+            if (this.graphConnectionUsed) {
+                await this.getGraphService().disconnect().catch(() => { });
+                await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                if (this._brokersService)
+                    await this._brokersService.disconnectAll().catch(() => { });
+                await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                await this.getProcessorService().disconnectSmsClients().catch(() => { });
+            }
+            return {
+                status: types_1.WorkflowStatus.FAILED,
+                workflow_id: this.state.workflow_id,
+                error: errorSummary,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                step_timings: this.state.step_timings,
+                failed_step: this.state.current_step,
+            };
+        }
+    }
+    /**
+     * Execute a single step
+     */
+    async executeStep(step) {
+        const startTime = Date.now();
+        debugLog('[WorkflowExecutor] executeStep ENTRY', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            step_type: step.type,
+        });
+        let resolvedInput = {};
+        try {
+            // Resolve input with data references and all $ operators
+            resolvedInput = (await this.resolveInput(step.input || {}));
+            debugLog('[WorkflowExecutor] executeStep input', {
+                workflow_id: this.state.workflow_id,
+                step_tag: step.tag,
+                input: resolvedInput,
+            });
+            let output;
+            // Route steps to dedicated services; only action and notification use ProcessorService.
+            switch (step.type) {
+                case types_1.WorkflowStepType.ACTION:
+                    output = await this.executeActionStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.DATABASE_ACTION:
+                    output = await this.executeDatabaseStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.NOTIFICATION:
+                    output = await this.executeNotificationStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.STORAGE:
+                    output = await this.executeStorageStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.PUBLISH:
+                case types_1.WorkflowStepType.PRODUCE:
+                    output = await this.executeProduceStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.GRAPH:
+                    output = await this.executeGraphStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.VECTOR:
+                    output = await this.executeVectorStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.QUOTA:
+                    output = await this.executeQuotaStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.FALLBACK:
+                    output = await this.executeFallbackStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.CHILD_WORKFLOW:
+                    output = await this.executeChildWorkflowStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.SLEEP:
+                    await this.executeSleepStep(step, resolvedInput);
+                    output = { slept: true };
+                    break;
+                case types_1.WorkflowStepType.WAIT_FOR_SIGNAL:
+                    output = await this.executeWaitForSignalStep(step, resolvedInput);
+                    break;
+                case types_1.WorkflowStepType.CHECKPOINT:
+                    await this.executeCheckpointStep(step, resolvedInput);
+                    output = { checkpoint: step.tag };
+                    break;
+                default:
+                    stepLog('Step type not implemented (passthrough)', { tag: step.tag, type: step.type });
+                    debugLog('[WorkflowExecutor] executeStep unknown step type (passthrough)', { step_tag: step.tag, step_type: step.type });
+                    output = resolvedInput;
+            }
+            // For action steps with no app: if step.output is a template with $ refs (e.g. $Sequence{main}{step-a}{value}-b),
+            // resolve it so downstream steps get the correct value (checkpoint / closure-style steps).
+            if (step.type === types_1.WorkflowStepType.ACTION &&
+                !step.app &&
+                step.output &&
+                typeof step.output === 'object' &&
+                !Array.isArray(step.output) &&
+                this.hasOperatorRefsInOutput(step.output)) {
+                try {
+                    output = (await this.resolveInput(step.output));
+                }
+                catch (_a) {
+                    // keep output from executeActionStep if resolve fails
+                }
+            }
+            const duration = Date.now() - startTime;
+            debugLog('[WorkflowExecutor] executeStep output', {
+                workflow_id: this.state.workflow_id,
+                step_tag: step.tag,
+                output,
+                durationMs: duration,
+            });
+            return {
+                success: true,
+                input: resolvedInput,
+                output,
+                duration,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const details = formatErrorDetails(error);
+            // Use API reason when present so we log why it failed (e.g. "Notification X not found") not just "Request failed with status code 500"
+            const stepErrorMsg = details.reason != null
+                ? (details.status != null ? `${details.reason} (HTTP ${details.status})` : details.reason)
+                : (details.status != null ? `${details.message} (HTTP ${details.status})` : details.message);
+            debugLog('[WorkflowExecutor] executeStep FAILED', Object.assign(Object.assign({ workflow_id: this.state.workflow_id, step_tag: step.tag, step_type: step.type, durationMs: duration, input: resolvedInput, error: stepErrorMsg }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: details.responseBody })));
+            return {
+                success: false,
+                input: resolvedInput,
+                error: stepErrorMsg,
+                duration,
+            };
+        }
+    }
+    /**
+     * Execute an action step
+     */
+    async executeActionStep(step, input) {
+        var _a, _b;
+        debugLog('[WorkflowExecutor] executeActionStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, app: step.app });
+        // Step that only returns (no component call): no app → passthrough, output = resolved input
+        if (!step.app) {
+            return input;
+        }
+        return this.getProcessorService().processAction({
+            product: this.state.product,
+            env: this.state.env,
+            app: step.app,
+            action: step.event,
+            input: input,
+            retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+            cache: (_b = step.options) === null || _b === void 0 ? void 0 : _b.cache,
+            preloadedBootstrap: this.stepBootstrapCache.get(step.tag),
+        });
+    }
+    /**
+     * Execute a database step: use query/insert/update/delete/upsert for DB operations, execute() for named actions.
+     */
+    async executeDatabaseStep(step, input) {
+        const database = step.database;
+        const product = this.state.product;
+        const env = this.state.env;
+        const event = (step.event || '').toLowerCase();
+        const db = this.getDatabaseService();
+        const opts = Object.assign({ product, env, database }, input);
+        debugLog('[WorkflowExecutor] executeDatabaseStep', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            database,
+            event,
+        });
+        switch (event) {
+            case 'query':
+                return db.query(opts);
+            case 'insert':
+                return db.insert(opts);
+            case 'update':
+                return db.update(opts);
+            case 'delete':
+                return db.delete(opts);
+            case 'upsert':
+                return db.upsert(opts);
+            default:
+                return db.execute({
+                    product,
+                    env,
+                    database,
+                    action: step.event,
+                    input: input,
+                });
+        }
+    }
+    /**
+     * Execute a notification step
+     */
+    async executeNotificationStep(step, input) {
+        var _a;
+        const event = `${step.notification}:${step.event}`;
+        debugLog('[WorkflowExecutor] executeNotificationStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, event });
+        return this.getProcessorService().processNotification({
+            product: this.state.product,
+            env: this.state.env,
+            event,
+            input: input,
+            retries: ((_a = step.options) === null || _a === void 0 ? void 0 : _a.retries) || 0,
+            preloadedBootstrap: this.stepBootstrapCache.get(step.tag),
+        });
+    }
+    /**
+     * Execute a storage step using StorageService (upload, download, or delete by input shape).
+     */
+    async executeStorageStep(step, input) {
+        var _a, _b;
+        const product = this.state.product;
+        const env = this.state.env;
+        const storage = step.storage;
+        const opts = { product, env, storage };
+        debugLog('[WorkflowExecutor] executeStorageStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, storage, event: step.event });
+        const inp = input;
+        if (inp.buffer != null && inp.fileName != null) {
+            return this.getStorageService().upload(Object.assign(Object.assign({}, opts), { fileName: String(inp.fileName), buffer: inp.buffer, mimeType: inp.mimeType != null ? String(inp.mimeType) : undefined }));
+        }
+        if (inp.file_key != null) {
+            return this.getStorageService().delete(Object.assign(Object.assign({}, opts), { fileName: String(inp.file_key) }));
+        }
+        return this.getStorageService().download(Object.assign(Object.assign({}, opts), { fileName: String((_b = (_a = inp.fileName) !== null && _a !== void 0 ? _a : inp.file_key) !== null && _b !== void 0 ? _b : '') }));
+    }
+    /**
+     * Execute a produce step (message broker produce to topic).
+     * Uses BrokersService so ctx.messaging.produce has the same behavior as ductape.messaging.produce (pool, tracking, cache).
+     */
+    async executeProduceStep(step, input) {
+        const event = `${step.broker}:${step.event}`;
+        const message = (input && input.message != null) ? input.message : (input || {});
+        debugLog('[WorkflowExecutor] executeProduceStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, event });
+        return this.getBrokersService().publish({
+            product: this.state.product,
+            env: this.state.env,
+            event,
+            message: message,
+        });
+    }
+    /**
+     * Execute a graph step
+     * Supports: execute (custom action), createNode, updateNode, deleteNode,
+     * createRelationship, deleteRelationship, query
+     */
+    async executeGraphStep(step, input) {
+        const graphTag = step.graph;
+        const action = step.event;
+        debugLog('[WorkflowExecutor] executeGraphStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, graph: graphTag, action });
+        this.graphConnectionUsed = true;
+        await this.getGraphService().connect({
+            env: this.state.env,
+            product: this.state.product,
+            graph: graphTag,
+        });
+        try {
+            // Handle different graph operations based on action
+            switch (action) {
+                case 'createNode': {
+                    const result = await this.getGraphService().createNode({
+                        labels: input.labels,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'updateNode': {
+                    const result = await this.getGraphService().updateNode({
+                        id: input.id,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'deleteNode': {
+                    const result = await this.getGraphService().deleteNode({
+                        id: input.id,
+                        detach: input.detach,
+                    });
+                    return result;
+                }
+                case 'createRelationship': {
+                    const result = await this.getGraphService().createRelationship({
+                        startNodeId: input.startNodeId || input.from,
+                        endNodeId: input.endNodeId || input.to,
+                        type: input.type,
+                        properties: input.properties,
+                    });
+                    return result;
+                }
+                case 'deleteRelationship': {
+                    const result = await this.getGraphService().deleteRelationship({
+                        id: input.id,
+                    });
+                    return result;
+                }
+                case 'query': {
+                    const result = await this.getGraphService().query(input.query, input.params);
+                    return result;
+                }
+                case 'findNodes': {
+                    const result = await this.getGraphService().findNodes({
+                        labels: input.labels,
+                        where: input.where,
+                        limit: input.limit,
+                        skip: input.skip,
+                    });
+                    return result;
+                }
+                case 'traverse': {
+                    const result = await this.getGraphService().traverse({
+                        startNodeId: input.startNodeId,
+                        relationshipTypes: input.relationshipTypes,
+                        direction: input.direction,
+                        maxDepth: input.maxDepth,
+                    });
+                    return result;
+                }
+                default: {
+                    // Execute a custom graph action
+                    const result = await this.getGraphService().execute({
+                        product: this.state.product,
+                        env: this.state.env,
+                        graph: graphTag,
+                        action,
+                        input,
+                    });
+                    return result;
+                }
+            }
+        }
+        finally {
+            // Disconnect is done once at end of execute() when graphConnectionUsed (see 2.8 optimization)
+        }
+    }
+    /**
+     * Execute a vector step (query, upsert, deleteVectors, or custom action via execute).
+     */
+    async executeVectorStep(step, input) {
+        var _a;
+        const vectorTag = step.vector;
+        if (!vectorTag) {
+            throw new Error(`Vector step "${step.tag}" has no vector tag`);
+        }
+        const product = this.state.product;
+        const env = this.state.env;
+        const event = (step.event || '').toLowerCase();
+        const svc = this.getVectorService();
+        debugLog('[WorkflowExecutor] executeVectorStep', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            vector: vectorTag,
+            event,
+        });
+        switch (event) {
+            case 'query': {
+                const result = await svc.query(Object.assign({ product,
+                    env, tag: vectorTag }, input));
+                return result;
+            }
+            case 'upsert': {
+                const result = await svc.upsert(Object.assign({ product,
+                    env, tag: vectorTag }, input));
+                return result;
+            }
+            case 'delete':
+            case 'deletevectors': {
+                const result = await svc.deleteVectors(Object.assign({ product,
+                    env, tag: vectorTag }, input));
+                return result;
+            }
+            default: {
+                // Custom vector action: resolve template then execute (resolve returns options for query/upsert/delete)
+                const resolved = await svc.actions.resolve({
+                    product,
+                    env,
+                    vector: vectorTag,
+                    action: step.event,
+                    input: input,
+                });
+                const op = (_a = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _a !== void 0 ? _a : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
+                const opts = Object.assign({ product, env, tag: vectorTag }, resolved);
+                if (op === 'query' || !op) {
+                    return svc.query(opts);
+                }
+                if (op === 'upsert') {
+                    return svc.upsert(opts);
+                }
+                if (op === 'delete' || op === 'deleteVectors') {
+                    return svc.deleteVectors(opts);
+                }
+                return svc.query(opts);
+            }
+        }
+    }
+    /**
+     * Execute a quota step
+     */
+    async executeQuotaStep(step, input) {
+        debugLog('[WorkflowExecutor] executeQuotaStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, quota: step.quota });
+        return this.getQuotaService().run({
+            product: this.state.product,
+            env: this.state.env,
+            tag: step.quota,
+            input,
+        });
+    }
+    /**
+     * Execute a fallback step
+     */
+    async executeFallbackStep(step, input) {
+        debugLog('[WorkflowExecutor] executeFallbackStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, fallback: step.fallback });
+        return this.getFallbackService().run({
+            product: this.state.product,
+            env: this.state.env,
+            tag: step.fallback,
+            input,
+        });
+    }
+    /**
+     * Execute a child workflow step
+     */
+    async executeChildWorkflowStep(step, input) {
+        let childTag = step.workflow;
+        if (childTag == null) {
+            const fromResolved = input === null || input === void 0 ? void 0 : input.workflow;
+            const fromStepInput = step.input && typeof step.input === 'object' ? step.input.workflow : undefined;
+            childTag = typeof fromResolved === 'string' ? fromResolved : typeof fromStepInput === 'string' ? fromStepInput : undefined;
+        }
+        debugLog('[WorkflowExecutor] executeChildWorkflowStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, child_workflow: childTag });
+        if (!childTag) {
+            throw new Error('Child workflow step has no workflow tag (missing workflow or step.input.workflow)');
+        }
+        const childWorkflow = await this.productBuilder.fetchWorkflow(childTag);
+        if (!childWorkflow) {
+            debugLog('[WorkflowExecutor] executeChildWorkflowStep child not found', { step_tag: step.tag, child_workflow: childTag });
+            throw new Error(`Child workflow ${childTag} not found`);
+        }
+        const childExecutor = new WorkflowExecutor(this.config, childWorkflow, {
+            product: this.state.product,
+            env: this.state.env,
+            tag: childTag,
+            input,
+        }, this._privateKey);
+        const result = await childExecutor.execute();
+        debugLog('[WorkflowExecutor] executeChildWorkflowStep result', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            child_status: result.status,
+        });
+        if (result.status !== types_1.WorkflowStatus.COMPLETED) {
+            throw new Error(`Child workflow failed: ${result.error}`);
+        }
+        return result.output;
+    }
+    /**
+     * Execute a sleep step
+     */
+    async executeSleepStep(step, input) {
+        var _a;
+        const duration = input.duration || ((_a = step.options) === null || _a === void 0 ? void 0 : _a.timeout) || 1000;
+        debugLog('[WorkflowExecutor] executeSleepStep', { workflow_id: this.state.workflow_id, step_tag: step.tag, durationMs: duration });
+        await this.sleep(duration);
+    }
+    /**
+     * Execute a wait for signal step
+     * Polls the backend API for signal delivery until received or timeout
+     */
+    async executeWaitForSignalStep(step, input) {
+        var _a;
+        const signalName = step.event;
+        const signals = input.signals || [signalName];
+        const timeout = ((_a = step.options) === null || _a === void 0 ? void 0 : _a.timeout) || 300000; // 5 min default
+        const startTime = Date.now();
+        debugLog('[WorkflowExecutor] executeWaitForSignalStep', {
+            workflow_id: this.state.workflow_id,
+            step_tag: step.tag,
+            signals,
+            timeoutMs: timeout,
+        });
+        // Store that we're waiting for these signals in state
+        this.state.state[`waiting_for_signal:${step.tag}`] = {
+            signals,
+            started_at: startTime,
+            timeout,
+        };
+        // Persist the waiting state to backend
+        await this.persistExecutionResult(types_1.LogEventStatus.WAITING);
+        return new Promise((resolve, reject) => {
+            // Create pending signal entry
+            const pendingSignal = {
+                signal: signalName,
+                resolve,
+                reject,
+            };
+            // Store for each signal we're waiting for
+            for (const sig of signals) {
+                this.pendingSignals.set(sig, pendingSignal);
+            }
+            // Set up timeout
+            if (timeout > 0) {
+                pendingSignal.timeout = setTimeout(() => {
+                    // Clean up pending signals
+                    for (const sig of signals) {
+                        this.pendingSignals.delete(sig);
+                    }
+                    this.stopSignalPolling();
+                    // Update state
+                    delete this.state.state[`waiting_for_signal:${step.tag}`];
+                    this.state.state[`signal_timeout:${step.tag}`] = {
+                        signals,
+                        timed_out_at: Date.now(),
+                    };
+                    reject(new Error(`Signal wait timed out after ${timeout}ms waiting for: ${signals.join(', ')}`));
+                }, timeout);
+            }
+            // Start polling for signals
+            this.startSignalPolling(signals, step.tag);
+        });
+    }
+    /**
+     * Start polling the backend for signal delivery
+     */
+    startSignalPolling(signals, stepTag) {
+        // Don't start multiple pollers
+        if (this.signalPollTimer)
+            return;
+        debugLog('[WorkflowExecutor] startSignalPolling', { workflow_id: this.state.workflow_id, stepTag, signals });
+        const poll = async () => {
+            var _a;
+            try {
+                // Get workflow status from backend to check for received signals
+                const status = await this.workflowApiService.getStatus(this.state.workflow_id, this.state.product, this.state.env, this.getAuthPayload());
+                if (status) {
+                    // Check if any of the signals we're waiting for have been received
+                    const receivedSignals = ((_a = status.state) === null || _a === void 0 ? void 0 : _a.received_signals) || {};
+                    for (const signalName of signals) {
+                        const signalKey = `signal:${signalName}`;
+                        if (receivedSignals[signalKey]) {
+                            const signalData = receivedSignals[signalKey];
+                            const pendingSignal = this.pendingSignals.get(signalName);
+                            if (pendingSignal) {
+                                // Clear timeout
+                                if (pendingSignal.timeout) {
+                                    clearTimeout(pendingSignal.timeout);
+                                }
+                                // Clean up
+                                for (const sig of signals) {
+                                    this.pendingSignals.delete(sig);
+                                }
+                                this.stopSignalPolling();
+                                // Update state
+                                delete this.state.state[`waiting_for_signal:${stepTag}`];
+                                this.state.state[`signal_received:${stepTag}`] = {
+                                    signal: signalName,
+                                    payload: signalData,
+                                    received_at: Date.now(),
+                                };
+                                // Resolve the promise
+                                pendingSignal.resolve({
+                                    signal: signalName,
+                                    payload: signalData,
+                                    received_at: Date.now(),
+                                });
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                // Log but continue polling - transient errors shouldn't stop us
+                debugLog('[WorkflowExecutor] Signal polling error', { workflow_id: this.state.workflow_id, error });
+            }
+            // Schedule next poll if we still have pending signals
+            if (this.pendingSignals.size > 0) {
+                this.signalPollTimer = setTimeout(poll, this.signalPollInterval);
+            }
+        };
+        // Start polling
+        poll();
+    }
+    /**
+     * Stop the signal polling timer
+     */
+    stopSignalPolling() {
+        if (this.signalPollTimer) {
+            clearTimeout(this.signalPollTimer);
+            this.signalPollTimer = null;
+        }
+    }
+    /**
+     * Deliver a signal to this workflow (called by external signal handler)
+     */
+    deliverSignal(signalName, payload) {
+        debugLog('[WorkflowExecutor] deliverSignal', { workflow_id: this.state.workflow_id, signalName, hasPayload: payload !== undefined });
+        const pendingSignal = this.pendingSignals.get(signalName);
+        if (!pendingSignal) {
+            debugLog('[WorkflowExecutor] deliverSignal no pending signal', { workflow_id: this.state.workflow_id, signalName });
+            return false;
+        }
+        // Clear timeout
+        if (pendingSignal.timeout) {
+            clearTimeout(pendingSignal.timeout);
+        }
+        // Clean up all related pending signals
+        // (in case we were waiting for multiple signals)
+        for (const [key, value] of this.pendingSignals.entries()) {
+            if (value === pendingSignal) {
+                this.pendingSignals.delete(key);
+            }
+        }
+        this.stopSignalPolling();
+        // Resolve with the signal data
+        pendingSignal.resolve({
+            signal: signalName,
+            payload,
+            received_at: Date.now(),
+        });
+        return true;
+    }
+    /**
+     * Execute a checkpoint step
+     */
+    async executeCheckpointStep(step, input) {
+        debugLog('[WorkflowExecutor] executeCheckpointStep', { workflow_id: this.state.workflow_id, step_tag: step.tag });
+        // Store checkpoint data in workflow state
+        this.state.state[`checkpoint:${step.tag}`] = {
+            timestamp: Date.now(),
+            completed_steps: [...this.state.completed_steps],
+            data: input,
+        };
+    }
+    /**
+     * Execute rollback for completed steps
+     */
+    async executeRollback(failedStep, reason) {
+        var _a;
+        const rolledBackSteps = [];
+        const failedRollbacks = [];
+        // Get rollback strategy
+        const strategy = ((_a = this.workflow.options) === null || _a === void 0 ? void 0 : _a.rollback_strategy) || types_1.WorkflowRollbackStrategy.REVERSE_ALL;
+        debugLog('[WorkflowExecutor] executeRollback ENTRY', {
+            workflow_id: this.state.workflow_id,
+            failedStep,
+            reason,
+            strategy,
+            completed_steps: this.state.completed_steps,
+        });
+        // Determine which steps to rollback
+        let stepsToRollback = [];
+        switch (strategy) {
+            case types_1.WorkflowRollbackStrategy.REVERSE_ALL:
+                // Rollback all completed steps in reverse order
+                stepsToRollback = this.state.completed_steps
+                    .slice()
+                    .reverse()
+                    .map((tag) => this.findStep(tag))
+                    .filter((step) => step !== undefined);
+                break;
+            case types_1.WorkflowRollbackStrategy.REVERSE_CRITICAL:
+                // Only rollback steps marked as critical
+                stepsToRollback = this.state.completed_steps
+                    .slice()
+                    .reverse()
+                    .map((tag) => this.findStep(tag))
+                    .filter((step) => { var _a; return step !== undefined && ((_a = step.options) === null || _a === void 0 ? void 0 : _a.critical) === true; });
+                break;
+            case types_1.WorkflowRollbackStrategy.NONE:
+                // No rollback
+                debugLog('[WorkflowExecutor] executeRollback NONE strategy', { workflow_id: this.state.workflow_id });
+                return { success: true, rolled_back_steps: [], reason };
+        }
+        debugLog('[WorkflowExecutor] executeRollback steps to rollback', {
+            workflow_id: this.state.workflow_id,
+            count: stepsToRollback.length,
+            tags: stepsToRollback.map((s) => s.tag),
+        });
+        // Execute rollback for each step
+        for (const step of stepsToRollback) {
+            if (!step.rollback) {
+                debugLog('[WorkflowExecutor] executeRollback step has no rollback', { step_tag: step.tag });
+                continue; // No rollback defined for this step
+            }
+            try {
+                const stepOutput = this.state.steps[step.tag];
+                await this.executeRollbackHandler(step.rollback, stepOutput);
+                rolledBackSteps.push(step.tag);
+                debugLog('[WorkflowExecutor] executeRollback step rolled back', { workflow_id: this.state.workflow_id, step_tag: step.tag });
+            }
+            catch (error) {
+                debugLog('[WorkflowExecutor] executeRollback step failed', { workflow_id: this.state.workflow_id, step_tag: step.tag, error: error === null || error === void 0 ? void 0 : error.message });
+                if (!step.rollback.continue_on_failure) {
+                    failedRollbacks.push({ tag: step.tag, error: error.message });
+                    // Stop rollback if continue_on_failure is not set
+                    break;
+                }
+                failedRollbacks.push({ tag: step.tag, error: error.message });
+            }
+        }
+        const rollbackResult = {
+            success: failedRollbacks.length === 0,
+            rolled_back_steps: rolledBackSteps,
+            failed_steps: failedRollbacks.length > 0 ? failedRollbacks : undefined,
+            reason,
+        };
+        debugLog('[WorkflowExecutor] executeRollback DONE', {
+            workflow_id: this.state.workflow_id,
+            success: rollbackResult.success,
+            rolled_back_count: rolledBackSteps.length,
+            failed_count: failedRollbacks.length,
+        });
+        return rollbackResult;
+    }
+    /**
+     * Execute a rollback handler
+     */
+    async executeRollbackHandler(rollback, stepOutput) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (!rollback)
+            return;
+        debugLog('[WorkflowExecutor] executeRollbackHandler', { workflow_id: this.state.workflow_id, rollback_type: rollback.type });
+        // Resolve rollback input, including step output references
+        const resolvedInput = await this.resolveInput(rollback.input || {}, stepOutput);
+        switch (rollback.type) {
+            case types_1.WorkflowStepType.ACTION:
+                await this.getProcessorService().processAction({
+                    product: this.state.product,
+                    env: this.state.env,
+                    app: rollback.app,
+                    action: rollback.event,
+                    input: resolvedInput,
+                    retries: (_a = rollback.retries) !== null && _a !== void 0 ? _a : 0,
+                });
+                break;
+            case types_1.WorkflowStepType.DATABASE_ACTION: {
+                const db = this.getDatabaseService();
+                const product = this.state.product;
+                const env = this.state.env;
+                const database = rollback.database;
+                const event = ((_b = rollback.event) !== null && _b !== void 0 ? _b : '').toLowerCase();
+                const opts = Object.assign({ product, env, database }, resolvedInput);
+                if (event === 'query')
+                    await db.query(opts);
+                else if (event === 'insert')
+                    await db.insert(opts);
+                else if (event === 'update')
+                    await db.update(opts);
+                else if (event === 'delete')
+                    await db.delete(opts);
+                else if (event === 'upsert')
+                    await db.upsert(opts);
+                else
+                    await db.execute({
+                        product,
+                        env,
+                        database,
+                        action: rollback.event,
+                        input: resolvedInput,
+                    });
+                break;
+            }
+            case types_1.WorkflowStepType.NOTIFICATION:
+                const notifEvent = `${rollback.notification}:${rollback.event}`;
+                await this.getProcessorService().processNotification({
+                    product: this.state.product,
+                    env: this.state.env,
+                    event: notifEvent,
+                    input: resolvedInput,
+                    retries: (_c = rollback.retries) !== null && _c !== void 0 ? _c : 0,
+                });
+                break;
+            case types_1.WorkflowStepType.STORAGE: {
+                const product = this.state.product;
+                const env = this.state.env;
+                const storage = rollback.storage;
+                const opts = { product, env, storage };
+                const inp = resolvedInput;
+                if (inp.buffer != null && inp.fileName != null) {
+                    await this.getStorageService().upload(Object.assign(Object.assign({}, opts), { fileName: String(inp.fileName), buffer: inp.buffer, mimeType: inp.mimeType != null ? String(inp.mimeType) : undefined }));
+                }
+                else if (inp.file_key != null) {
+                    await this.getStorageService().delete(Object.assign(Object.assign({}, opts), { fileName: String(inp.file_key) }));
+                }
+                else {
+                    await this.getStorageService().download(Object.assign(Object.assign({}, opts), { fileName: String((_e = (_d = inp.fileName) !== null && _d !== void 0 ? _d : inp.file_key) !== null && _e !== void 0 ? _e : '') }));
+                }
+                break;
+            }
+            case types_1.WorkflowStepType.VECTOR: {
+                const product = this.state.product;
+                const env = this.state.env;
+                const vectorTag = rollback.vector;
+                const inp = resolvedInput;
+                const event = ((_f = rollback.event) !== null && _f !== void 0 ? _f : '').toLowerCase();
+                const svc = this.getVectorService();
+                if (event === 'query') {
+                    await svc.query(Object.assign({ product, env, tag: vectorTag }, inp));
+                }
+                else if (event === 'upsert') {
+                    await svc.upsert(Object.assign({ product, env, tag: vectorTag }, inp));
+                }
+                else if (event === 'delete' || event === 'deletevectors') {
+                    await svc.deleteVectors(Object.assign({ product, env, tag: vectorTag }, inp));
+                }
+                else {
+                    const resolved = await svc.actions.resolve({
+                        product,
+                        env,
+                        vector: vectorTag,
+                        action: rollback.event,
+                        input: inp,
+                    });
+                    const op = (_g = resolved === null || resolved === void 0 ? void 0 : resolved._operation) !== null && _g !== void 0 ? _g : resolved === null || resolved === void 0 ? void 0 : resolved.operation;
+                    const opts = Object.assign({ product, env, tag: vectorTag }, resolved);
+                    if (op === 'upsert')
+                        await svc.upsert(opts);
+                    else if (op === 'delete' || op === 'deleteVectors')
+                        await svc.deleteVectors(opts);
+                    else
+                        await svc.query(opts);
+                }
+                break;
+            }
+            case types_1.WorkflowStepType.PUBLISH:
+            case types_1.WorkflowStepType.PRODUCE:
+                const pubEvent = `${rollback.broker}:${rollback.event}`;
+                await this.getProcessorService().processMessageBrokerPublish({
+                    product: this.state.product,
+                    env: this.state.env,
+                    event: pubEvent,
+                    input: resolvedInput,
+                });
+                break;
+        }
+    }
+    /**
+     * Resolve input by replacing data references and all $ operators (per docs/operators).
+     * Top-level keys are resolved in parallel for better performance.
+     */
+    async resolveInput(input, stepOutput) {
+        const entries = Object.entries(input);
+        const resolvedValues = await Promise.all(entries.map(([, value]) => this.resolveValue(value, stepOutput)));
+        const resolved = {};
+        entries.forEach(([key], i) => {
+            resolved[key] = resolvedValues[i];
+        });
+        return resolved;
+    }
+    /**
+     * Resolve a single value: refs ($Input{}, $Step{}, etc.) and operators ($Add, $Concat, etc.)
+     */
+    async resolveValue(value, stepOutput) {
+        if (typeof value === 'string') {
+            return this.resolveStringValue(value, stepOutput);
+        }
+        if (Array.isArray(value)) {
+            return Promise.all(value.map((item) => this.resolveValue(item, stepOutput)));
+        }
+        if (value && typeof value === 'object') {
+            return this.resolveInput(value, stepOutput);
+        }
+        return value;
+    }
+    /** Strip surrounding quotes from a string literal (e.g. '"foo"' -> 'foo') */
+    unquote(part) {
+        const t = part.trim();
+        if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+            return t.slice(1, -1);
+        }
+        return t;
+    }
+    /**
+     * Resolve string value: data references and all $ operators from docs/operators
+     * Supports: $Input{}, $Step{}, $Sequence{}, $State{}, $StepOutput{}, $Now,
+     * $Add, $Subtract, $Concat, $Substring, $Trim, $Split, $Pick, $Join,
+     * $Uppercase, $Lowercase, $Dateformat, $Replace, $Filter, $Find, $Size, $Length
+     */
+    async resolveStringValue(value, stepOutput) {
+        var _a;
+        const v = value.trim();
+        // --- Data references (exact match) ---
+        if (v === '$Now' || v === '$Now()')
+            return Date.now();
+        const inputMatch = v.match(/^\$Input\{(.+)\}$/);
+        if (inputMatch)
+            return this.getNestedValue(this.state.input, inputMatch[1]);
+        const sequenceMatch = v.match(/^\$Sequence\{main\}\{([^}]+)\}\{(.+)\}$/);
+        if (sequenceMatch) {
+            const stepData = this.state.steps[sequenceMatch[1]];
+            if (stepData)
+                return this.getNestedValue(stepData, sequenceMatch[2]);
+            return undefined;
+        }
+        const stepMatch = v.match(/^\$Step\{(.+)\}\{(.+)\}$/);
+        if (stepMatch) {
+            const stepData = this.state.steps[stepMatch[1]];
+            if (stepData)
+                return this.getNestedValue(stepData, stepMatch[2]);
+            return undefined;
+        }
+        const stateMatch = v.match(/^\$State\{(.+)\}$/);
+        if (stateMatch)
+            return this.state.state[stateMatch[1]];
+        const outputMatch = v.match(/^\$StepOutput\{(.+)\}$/);
+        if (outputMatch && stepOutput)
+            return this.getNestedValue(stepOutput, outputMatch[1]);
+        // --- $Size{ref} / $Length{ref} ---
+        const sizeMatch = v.match(/^\$Size\{(.+)\}$/);
+        if (sizeMatch) {
+            const inner = await this.resolveValue(sizeMatch[1].trim(), stepOutput);
+            if (inner != null && typeof inner === 'object' && !Array.isArray(inner))
+                return Object.keys(inner).length;
+            return 0;
+        }
+        const lengthMatch = v.match(/^\$Length\{(.+)\}$/);
+        if (lengthMatch) {
+            const inner = await this.resolveValue(lengthMatch[1].trim(), stepOutput);
+            if (Array.isArray(inner))
+                return inner.length;
+            if (typeof inner === 'string')
+                return inner.length;
+            return 0;
+        }
+        // --- Operators (whole-string forms) ---
+        // $Add(...) or $Add{...}
+        const addMatch = v.match(/^\$Add\(([^)]*)\)$/) || v.match(/^\$Add\{([^}]*)\}$/);
+        if (addMatch) {
+            const parts = addMatch[1].split(',').map((s) => this.unquote(s.trim()));
+            const nums = await Promise.all(parts.map((p) => this.resolveValue(p, stepOutput)));
+            return nums.reduce((sum, n) => sum + Number(n), 0);
+        }
+        // $Subtract(...) / $Substract(...) (typo) and $Subtract{...}
+        const subMatch = v.match(/^\$Subtract?\(([^)]*)\)$/) || v.match(/^\$Subtract?\{([^}]*)\}$/);
+        if (subMatch) {
+            const parts = subMatch[1].split(',').map((s) => this.unquote(s.trim()));
+            const nums = await Promise.all(parts.map((p) => this.resolveValue(p, stepOutput)));
+            const n = nums.map((x) => Number(x));
+            return n.length ? n.reduce((a, b) => a - b) : 0;
+        }
+        // $Concat([...], "sep")
+        const concatMatch = v.match(inputs_types_1.concatRegex);
+        if (concatMatch) {
+            const arrContent = concatMatch[1];
+            const separator = concatMatch[2];
+            const parts = arrContent.split(',').map((s) => this.unquote(s.trim()));
+            const resolvedParts = await Promise.all(parts.map((p) => this.resolveValue(p, stepOutput)));
+            return resolvedParts.map((x) => (x == null ? '' : String(x))).join(separator);
+        }
+        // $Substring(str, start, end)
+        const substrMatch = v.match(inputs_types_1.substringRegex);
+        if (substrMatch) {
+            const str = await this.resolveValue(this.unquote(substrMatch[1]), stepOutput);
+            const start = Number(substrMatch[2]);
+            const end = Number(substrMatch[3]);
+            if (typeof str !== 'string')
+                return '';
+            return str.substring(start, end);
+        }
+        // $Trim(str)
+        const trimMatch = v.match(inputs_types_1.trimRegex);
+        if (trimMatch) {
+            const str = await this.resolveValue(this.unquote(trimMatch[1]), stepOutput);
+            return typeof str === 'string' ? str.trim() : String(str !== null && str !== void 0 ? str : '').trim();
+        }
+        // $Uppercase(str)
+        const upperMatch = v.match(inputs_types_1.uppercaseRegex);
+        if (upperMatch) {
+            const str = await this.resolveValue(this.unquote(upperMatch[1]), stepOutput);
+            return typeof str === 'string' ? str.toUpperCase() : String(str !== null && str !== void 0 ? str : '').toUpperCase();
+        }
+        // $Lowercase(str)
+        const lowerMatch = v.match(inputs_types_1.lowercaseRegex);
+        if (lowerMatch) {
+            const str = await this.resolveValue(this.unquote(lowerMatch[1]), stepOutput);
+            return typeof str === 'string' ? str.toLowerCase() : String(str !== null && str !== void 0 ? str : '').toLowerCase();
+        }
+        // $Dateformat(date, "format")
+        const dateMatch = v.match(inputs_types_1.dateFormatRegex);
+        if (dateMatch) {
+            const dateVal = await this.resolveValue(this.unquote(dateMatch[1]), stepOutput);
+            const formatStr = dateMatch[3];
+            const d = typeof dateVal === 'string' ? (0, date_fns_1.parseISO)(dateVal) : new Date(dateVal);
+            if (isNaN(d.getTime()))
+                return '';
+            return (0, date_fns_1.format)(d, formatStr);
+        }
+        // $Replace(str, search, replace)
+        const replaceMatch = v.match(inputs_types_1.replaceRegex);
+        if (replaceMatch) {
+            const str = await this.resolveValue(this.unquote(replaceMatch[1]), stepOutput);
+            const search = replaceMatch[3];
+            const repl = replaceMatch[5];
+            return typeof str === 'string' ? str.split(search).join(repl) : String(str !== null && str !== void 0 ? str : '');
+        }
+        // $Pick(value, index)
+        const pickMatch = v.match(inputs_types_1.pickRegex);
+        if (pickMatch) {
+            const val = await this.resolveValue(this.unquote(pickMatch[1]), stepOutput);
+            const idx = Number(pickMatch[2]);
+            if (typeof val === 'string' || Array.isArray(val))
+                return (_a = val[idx]) !== null && _a !== void 0 ? _a : '';
+            return '';
+        }
+        // $Filter(array, "op", value)
+        const filterMatch = v.match(inputs_types_1.filterRegex);
+        if (filterMatch) {
+            const arr = await this.resolveValue(this.unquote(filterMatch[1]), stepOutput);
+            const op = filterMatch[2].trim();
+            const compareVal = await this.resolveValue(this.unquote(filterMatch[3]), stepOutput);
+            if (!productsBuilder_types_1.ValidOperators.includes(op) || !Array.isArray(arr))
+                return [];
+            return arr.filter((item) => (0, processor_utils_1.compareValues)(item, op, compareVal));
+        }
+        // $Find(array, "op", value)
+        const findMatch = v.match(inputs_types_1.findRegex);
+        if (findMatch) {
+            const arr = await this.resolveValue(this.unquote(findMatch[1]), stepOutput);
+            const op = findMatch[2].trim();
+            const compareVal = await this.resolveValue(this.unquote(findMatch[3]), stepOutput);
+            if (!productsBuilder_types_1.ValidOperators.includes(op) || !Array.isArray(arr))
+                return undefined;
+            return arr.find((item) => (0, processor_utils_1.compareValues)(item, op, compareVal));
+        }
+        // $Split(str, "sep")
+        const splitMatch = v.match(inputs_types_1.splitRegex);
+        if (splitMatch) {
+            const str = await this.resolveValue(this.unquote(splitMatch[1]), stepOutput);
+            const sep = splitMatch[2];
+            return typeof str === 'string' ? str.split(sep) : [];
+        }
+        // $Join([[...], [...]]) - inner can be refs like $Sequence{main}{a}{data}
+        const joinMatch = v.match(inputs_types_1.joinRegex);
+        if (joinMatch) {
+            const innerStr = joinMatch[1].trim();
+            const parts = innerStr.slice(1, -1).split(',').map((s) => s.trim());
+            const resolved = await Promise.all(parts.map((p) => this.resolveValue(p, stepOutput)));
+            return resolved.reduce((acc, current) => {
+                if (Array.isArray(current))
+                    return acc.concat(current);
+                return acc;
+            }, []);
+        }
+        // --- Inline references (string contains $Input{}, $Step{}, $Now, etc.) ---
+        let out = value;
+        out = out.replace(/\$Now(?:\(\))?/g, () => String(Date.now()));
+        out = out.replace(/\$Input\{([^}]+)\}/g, (_, field) => {
+            const val = this.getNestedValue(this.state.input, field);
+            return String(val !== null && val !== void 0 ? val : '');
+        });
+        out = out.replace(/\$Sequence\{main\}\{([^}]+)\}\{([^}]+)\}/g, (_, stepTag, field) => {
+            const stepData = this.state.steps[stepTag];
+            if (stepData) {
+                const val = this.getNestedValue(stepData, field);
+                return String(val !== null && val !== void 0 ? val : '');
+            }
+            return '';
+        });
+        out = out.replace(/\$Step\{([^}]+)\}\{([^}]+)\}/g, (_, stepTag, field) => {
+            const stepData = this.state.steps[stepTag];
+            if (stepData) {
+                const val = this.getNestedValue(stepData, field);
+                return String(val !== null && val !== void 0 ? val : '');
+            }
+            return '';
+        });
+        return out;
+    }
+    /**
+     * Get nested value from object using dot notation
+     */
+    getNestedValue(obj, path) {
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[key];
+        }
+        return current;
+    }
+    /**
+     * Get ordered steps respecting dependencies
+     */
+    getOrderedSteps() {
+        const steps = this.workflow.steps;
+        const ordered = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (step) => {
+            if (visited.has(step.tag))
+                return;
+            if (visiting.has(step.tag)) {
+                throw new Error(`Circular dependency detected at step ${step.tag}`);
+            }
+            visiting.add(step.tag);
+            // Visit dependencies first
+            if (step.depends_on) {
+                for (const depTag of step.depends_on) {
+                    const depStep = steps.find((s) => s.tag === depTag);
+                    if (depStep) {
+                        visit(depStep);
+                    }
+                }
+            }
+            visiting.delete(step.tag);
+            visited.add(step.tag);
+            ordered.push(step);
+        };
+        for (const step of steps) {
+            visit(step);
+        }
+        return ordered;
+    }
+    /**
+     * Pre-fetch all action/notification/storage bootstrap data for the given steps in one backend call.
+     * Results are cached in stepBootstrapCache by step tag so step executors can skip their own bootstrap calls.
+     */
+    async prefetchStepBootstrap(steps) {
+        this.stepBootstrapCache.clear();
+        const product = this.state.product;
+        const env = this.state.env;
+        const workflowSteps = [];
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.ACTION && step.app) {
+                workflowSteps.push({
+                    step_tag: step.tag,
+                    type: 'action',
+                    access_tag: step.app,
+                    action_tag: step.event,
+                });
+            }
+            else if (step.type === types_1.WorkflowStepType.NOTIFICATION && step.notification && step.event) {
+                workflowSteps.push({
+                    step_tag: step.tag,
+                    type: 'notification',
+                    notification_tag: step.notification,
+                    message_tag: step.event,
+                });
+            }
+            else if (step.type === types_1.WorkflowStepType.STORAGE && step.storage && step.event) {
+                workflowSteps.push({
+                    step_tag: step.tag,
+                    type: 'storage',
+                    storage_tag: step.storage,
+                });
+            }
+        }
+        if (workflowSteps.length > 0) {
+            stepLog('Bootstrap workflow API call (single request)', {
+                product_tag: product,
+                env_slug: env,
+                steps_count: workflowSteps.length,
+                step_tags: workflowSteps.map((s) => s.step_tag),
+            });
+            const bootstraps = await this.productBuilder.bootstrapWorkflow({
+                product_tag: product,
+                env_slug: env,
+                steps: workflowSteps,
+            });
+            stepLog('Bootstrap workflow API response', {
+                received_keys: Object.keys(bootstraps),
+                keys_count: Object.keys(bootstraps).length,
+            });
+            for (const [stepTag, data] of Object.entries(bootstraps)) {
+                if (data != null) {
+                    this.stepBootstrapCache.set(stepTag, data);
+                }
+            }
+        }
+        // Pre-fetch message brokers for produce steps so runBrokerPublish has broker/topic in cache
+        const brokerTags = new Set();
+        for (const step of steps) {
+            if ((step.type === types_1.WorkflowStepType.PUBLISH || step.type === types_1.WorkflowStepType.PRODUCE) && step.broker) {
+                brokerTags.add(step.broker);
+            }
+        }
+        if (brokerTags.size > 0) {
+            stepLog('Fetching message brokers for produce steps', { broker_tags: [...brokerTags] });
+            await Promise.all([...brokerTags].map(async (tag) => {
+                var _a;
+                try {
+                    const broker = await this.productBuilder.fetchMessageBroker(tag);
+                    return { tag, found: !!broker };
+                }
+                catch (e) {
+                    stepLog('Broker fetch failed (step may fail later)', { broker_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch databases for DATABASE_ACTION steps
+        const databaseTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.DATABASE_ACTION && step.database) {
+                databaseTags.add(step.database);
+            }
+        }
+        if (databaseTags.size > 0) {
+            stepLog('Fetching databases for database steps', { database_tags: [...databaseTags] });
+            await Promise.all([...databaseTags].map(async (tag) => {
+                var _a;
+                try {
+                    const db = await this.productBuilder.fetchDatabase(tag);
+                    return { tag, found: !!db };
+                }
+                catch (e) {
+                    stepLog('Database fetch failed (step may fail later)', { database_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch graphs for GRAPH steps
+        const graphTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.GRAPH && step.graph) {
+                graphTags.add(step.graph);
+            }
+        }
+        if (graphTags.size > 0) {
+            stepLog('Fetching graphs for graph steps', { graph_tags: [...graphTags] });
+            await Promise.all([...graphTags].map(async (tag) => {
+                var _a;
+                try {
+                    const graph = await this.productBuilder.fetchGraph(tag);
+                    return { tag, found: !!graph };
+                }
+                catch (e) {
+                    stepLog('Graph fetch failed (step may fail later)', { graph_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        const vectorTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.VECTOR && step.vector) {
+                vectorTags.add(step.vector);
+            }
+        }
+        if (vectorTags.size > 0) {
+            stepLog('Fetching vectors for vector steps', { vector_tags: [...vectorTags] });
+            await Promise.all([...vectorTags].map(async (tag) => {
+                var _a;
+                try {
+                    const vec = await this.productBuilder.fetchVector(tag);
+                    return { tag, found: !!vec };
+                }
+                catch (e) {
+                    stepLog('Vector fetch failed (step may fail later)', { vector_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch quotas for QUOTA steps
+        const quotaTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.QUOTA && step.quota) {
+                quotaTags.add(step.quota);
+            }
+        }
+        if (quotaTags.size > 0) {
+            stepLog('Fetching quotas for quota steps', { quota_tags: [...quotaTags] });
+            await Promise.all([...quotaTags].map(async (tag) => {
+                var _a;
+                try {
+                    const quota = await this.productBuilder.fetchQuota(tag);
+                    return { tag, found: !!quota };
+                }
+                catch (e) {
+                    stepLog('Quota fetch failed (step may fail later)', { quota_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch fallbacks for FALLBACK steps
+        const fallbackTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.FALLBACK && step.fallback) {
+                fallbackTags.add(step.fallback);
+            }
+        }
+        if (fallbackTags.size > 0) {
+            stepLog('Fetching fallbacks for fallback steps', { fallback_tags: [...fallbackTags] });
+            await Promise.all([...fallbackTags].map(async (tag) => {
+                var _a;
+                try {
+                    const fallback = await this.productBuilder.fetchFallback(tag);
+                    return { tag, found: !!fallback };
+                }
+                catch (e) {
+                    stepLog('Fallback fetch failed (step may fail later)', { fallback_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch features for FEATURE steps (step.event is the feature tag)
+        const featureTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.FEATURE && step.event) {
+                featureTags.add(step.event);
+            }
+        }
+        if (featureTags.size > 0) {
+            stepLog('Fetching features for feature steps', { feature_tags: [...featureTags] });
+            await Promise.all([...featureTags].map(async (tag) => {
+                var _a;
+                try {
+                    const feature = await this.productBuilder.fetchFeature(tag);
+                    return { tag, found: !!feature };
+                }
+                catch (e) {
+                    stepLog('Feature fetch failed (step may fail later)', { feature_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-fetch child workflows for CHILD_WORKFLOW steps
+        const workflowTags = new Set();
+        for (const step of steps) {
+            if (step.type === types_1.WorkflowStepType.CHILD_WORKFLOW && step.workflow) {
+                workflowTags.add(step.workflow);
+            }
+        }
+        if (workflowTags.size > 0) {
+            stepLog('Fetching child workflows for child_workflow steps', { workflow_tags: [...workflowTags] });
+            await Promise.all([...workflowTags].map(async (tag) => {
+                var _a;
+                try {
+                    const workflow = await this.productBuilder.fetchWorkflow(tag);
+                    return { tag, found: !!workflow };
+                }
+                catch (e) {
+                    stepLog('Child workflow fetch failed (step may fail later)', { workflow_tag: tag, error: (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : String(e) });
+                    return { tag, found: false };
+                }
+            }));
+        }
+        // Pre-connect brokers, graphs, and databases so step execution reuses connections.
+        // Security: product/env from this.state (same execution context). No connection URLs, config, or
+        // credentials are ever logged. On pre-connect failure we log only tags and a generic message.
+        if (brokerTags.size > 0) {
+            stepLog('Pre-warming broker connections', { broker_tags: [...brokerTags] });
+            try {
+                await this.getBrokersService().warmBrokerConnections({ product, env, brokerTags: [...brokerTags] });
+            }
+            catch (_a) {
+                stepLog('Broker pre-warm failed (steps may connect on first use)', { broker_tags: [...brokerTags] });
+            }
+        }
+        if (graphTags.size > 0) {
+            stepLog('Pre-connecting graph connections', { graph_tags: [...graphTags] });
+            await Promise.all([...graphTags].map((tag) => this.getGraphService()
+                .connect({ product, env, graph: tag })
+                .catch(() => {
+                stepLog('Graph pre-connect failed (step may connect on first use)', { graph_tag: tag });
+            })));
+        }
+        if (databaseTags.size > 0) {
+            stepLog('Pre-connecting database connections', { database_tags: [...databaseTags] });
+            await Promise.all([...databaseTags].map((tag) => this.getDatabaseService()
+                .connect({ product, env, database: tag })
+                .catch(() => {
+                stepLog('Database pre-connect failed (step may connect on first use)', { database_tag: tag });
+            })));
+        }
+        if (vectorTags.size > 0) {
+            stepLog('Pre-connecting vector connections', { vector_tags: [...vectorTags] });
+            await Promise.all([...vectorTags].map((tag) => this.getVectorService()
+                .connect({ product, env, vector: tag })
+                .catch(() => {
+                stepLog('Vector pre-connect failed (step may connect on first use)', { vector_tag: tag });
+            })));
+        }
+    }
+    /**
+     * Find a step by tag
+     */
+    findStep(tag) {
+        return this.workflow.steps.find((s) => s.tag === tag);
+    }
+    /**
+     * Evaluate a condition string.
+     * Supports: (cond1) || (cond2), (cond1) && (cond2), and in each part: ==, ===, !=, !==, >, <, >=, <=.
+     * Left/right can be $Step{}, $Input{}, etc. (resolved before comparison).
+     */
+    async evaluateCondition(condition) {
+        try {
+            const orParts = condition.split(/\s*\|\|\s*/).map((p) => p.trim());
+            for (const orPart of orParts) {
+                const trimmed = orPart.replace(/^\(|\)$/g, '').trim();
+                const andParts = trimmed.split(/\s*&&\s*/).map((p) => p.trim());
+                let andResult = true;
+                for (const andPart of andParts) {
+                    if (!(await this.evaluateConditionPart(andPart))) {
+                        andResult = false;
+                        break;
+                    }
+                }
+                if (andResult)
+                    return true;
+            }
+            return false;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Coerce a trimmed condition literal (after resolve) to a comparable value: boolean, number, or string.
+     */
+    conditionLiteral(val) {
+        const s = val.replace(/^["']|["']$/g, '').trim();
+        if (s === 'true')
+            return true;
+        if (s === 'false')
+            return false;
+        if (s === 'null')
+            return null;
+        const n = Number(s);
+        if (s !== '' && !Number.isNaN(n))
+            return n;
+        return s;
+    }
+    async evaluateConditionPart(condition) {
+        try {
+            const resolved = await this.resolveStringValue(condition);
+            if (typeof resolved !== 'string') {
+                return Boolean(resolved);
+            }
+            const match = resolved.match(WorkflowExecutor.CONDITION_OP_REGEX);
+            if (!match) {
+                return Boolean(this.conditionLiteral(resolved.trim()));
+            }
+            const [, leftStr, op, rightStr] = match;
+            const left = this.conditionLiteral(leftStr.trim());
+            const right = this.conditionLiteral(rightStr.trim());
+            switch (op) {
+                case '==':
+                case '===':
+                    return this.compareLooseEqual(left, right);
+                case '!=':
+                case '!==':
+                    return !this.compareLooseEqual(left, right);
+                case '>':
+                    return this.compareOrdered(left, right, (a, b) => a > b);
+                case '<':
+                    return this.compareOrdered(left, right, (a, b) => a < b);
+                case '>=':
+                    return this.compareOrdered(left, right, (a, b) => a >= b);
+                case '<=':
+                    return this.compareOrdered(left, right, (a, b) => a <= b);
+                default:
+                    return false;
+            }
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    compareLooseEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a == null && b == null)
+            return true;
+        if (typeof a === 'boolean' && typeof b === 'boolean')
+            return a === b;
+        if (typeof a === 'number' && typeof b === 'number')
+            return a === b;
+        return String(a) === String(b);
+    }
+    /**
+     * Compare for ordering (>, <, >=, <=). Uses numeric comparison when both sides are numeric, else string.
+     */
+    compareOrdered(left, right, cmp) {
+        const l = typeof left === 'number' ? left : Number(left);
+        const r = typeof right === 'number' ? right : Number(right);
+        const bothNumeric = !Number.isNaN(l) && !Number.isNaN(r);
+        if (bothNumeric)
+            return cmp(l, r);
+        return cmp(String(left !== null && left !== void 0 ? left : ''), String(right !== null && right !== void 0 ? right : ''));
+    }
+    /**
+     * Returns true if the value tree contains any $ operator reference ($Input{}, $Step{}, $Sequence{}, etc.).
+     * Used to distinguish output templates (to resolve) from type-only schemas (to ignore for persistence).
+     */
+    hasOperatorRefsInOutput(value) {
+        if (typeof value === 'string') {
+            const v = value.trim();
+            return /^\$((Input|Step|Sequence|State|StepOutput|Now|Add|Subtract|Concat|Size|Length|Pick|Filter|Find|Join|Split|Replace|Substring|Trim|Uppercase|Lowercase|Dateformat)\{|[A-Za-z]+\()/.test(v);
+        }
+        if (Array.isArray(value)) {
+            return value.some((item) => this.hasOperatorRefsInOutput(item));
+        }
+        if (value && typeof value === 'object') {
+            return Object.values(value).some((v) => this.hasOperatorRefsInOutput(v));
+        }
+        return false;
+    }
+    /**
+     * Returns true if the object looks like a workflow output type schema (e.g. { orderId: { type: 'string' }, ... })
+     * rather than a template with $ operators or literal values.
+     */
+    isOutputTypeSchema(output) {
+        if (Object.keys(output).length === 0)
+            return false;
+        return Object.values(output).every((v) => {
+            if (v != null && typeof v === 'object' && !Array.isArray(v)) {
+                const o = v;
+                return 'type' in o && typeof o.type === 'string';
+            }
+            return false;
+        });
+    }
+    /**
+     * Determine workflow output for persistence and return value.
+     * - If workflow.output has $ operator refs: resolve template to actual values (matches definition).
+     * - If workflow.output is a type-only schema: use execution result (last step or step_outputs) so stored result matches runtime output, not the schema.
+     * - If no workflow.output: use last step result or {}.
+     */
+    async determineWorkflowOutput() {
+        const outputDef = this.workflow.output;
+        if (!outputDef || Object.keys(outputDef).length === 0) {
+            const lastStep = this.state.completed_steps[this.state.completed_steps.length - 1];
+            return lastStep ? this.state.steps[lastStep] : {};
+        }
+        const hasRefs = this.hasOperatorRefsInOutput(outputDef);
+        let result;
+        if (hasRefs) {
+            result = this.resolveInput(outputDef);
+        }
+        else if (this.isOutputTypeSchema(outputDef)) {
+            const out = this.buildOutputFromStepsToMatchDefinition(outputDef);
+            result = Object.keys(out).length > 0 ? out : {};
+        }
+        else {
+            result = this.resolveInput(outputDef);
+        }
+        // recordScenarios: workflow.output is from last scenario; override outcome from which branch actually ran
+        if (result != null && typeof result === 'object' && 'outcome' in result) {
+            const res = result;
+            if (this.state.completed_steps.includes('approve-request'))
+                res.outcome = 'approved';
+            else if (this.state.completed_steps.includes('reject-request'))
+                res.outcome = 'rejected';
+        }
+        return result;
+    }
+    /**
+     * Build output with same keys as workflow definition, values from step_outputs (last step first, then others).
+     * Ensures persisted result shape matches the workflow definition output shape.
+     */
+    buildOutputFromStepsToMatchDefinition(definitionKeys) {
+        var _a;
+        const keys = Object.keys(definitionKeys);
+        if (keys.length === 0)
+            return {};
+        const out = {};
+        const stepsReversed = [...this.state.completed_steps].reverse();
+        for (const key of keys) {
+            let found = false;
+            for (const stepTag of stepsReversed) {
+                const stepData = this.state.steps[stepTag];
+                if (stepData == null || typeof stepData !== 'object')
+                    continue;
+                const rec = stepData;
+                if (key in rec) {
+                    out[key] = rec[key];
+                    found = true;
+                    break;
+                }
+                const nested = (_a = rec.output) !== null && _a !== void 0 ? _a : rec.result;
+                if (nested != null && typeof nested === 'object' && key in nested) {
+                    out[key] = nested[key];
+                    found = true;
+                    break;
+                }
+            }
+            // Handler return shape { a, b } often maps to steps step-a, step-b; use step output so out.a.value / out.b.value exist
+            if (!found && this.state.steps[`step-${key}`] != null) {
+                const stepResult = this.state.steps[`step-${key}`];
+                out[key] = ((stepResult === null || stepResult === void 0 ? void 0 : stepResult.output) != null ? stepResult.output : stepResult);
+            }
+        }
+        if (Object.keys(out).length === 0 && this.state.completed_steps.length > 0) {
+            const lastStep = this.state.completed_steps[this.state.completed_steps.length - 1];
+            const lastOutput = this.state.steps[lastStep];
+            return lastOutput != null && typeof lastOutput === 'object' ? lastOutput : {};
+        }
+        return out;
+    }
+    /**
+     * Sleep for specified duration
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Resume a workflow from a previous state
+     *
+     * @param options - Resume options including completed steps, state, and starting point
+     */
+    async resume(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const startTime = Date.now();
+        debugLog('[WorkflowExecutor] resume ENTRY', {
+            workflow_id: this.state.workflow_id,
+            workflow_tag: this.state.workflow_tag,
+            completed_steps_count: (_b = (_a = options.completed_steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
+            from_checkpoint: options.from_checkpoint,
+            from_step: options.from_step,
+            skip_steps: (_d = (_c = options.skip_steps) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0,
+        });
+        try {
+            // Track phase so failures before first step are reported as (initialization)
+            this.state.current_step = '(initialization)';
+            // Initialize product builder with the product
+            await this.productBuilder.initializeProductByTag(this.state.product);
+            this.productId = this.productBuilder.fetchProductId();
+            // Initialize logging after we have product ID
+            this.initializeLogging();
+            // Restore previous state
+            this.state.completed_steps = options.completed_steps || [];
+            this.state.state = options.state || {};
+            // Restore step outputs if provided
+            if (options.step_outputs) {
+                this.state.steps = Object.assign(Object.assign({}, this.state.steps), options.step_outputs);
+            }
+            this.state.status = types_1.WorkflowStatus.RUNNING;
+            // Get steps in execution order
+            const orderedSteps = this.getOrderedSteps();
+            // Find starting point
+            let startIndex = 0;
+            if (options.from_checkpoint) {
+                // Find the step after the checkpoint
+                const checkpointIndex = orderedSteps.findIndex((s) => s.type === types_1.WorkflowStepType.CHECKPOINT && s.tag === options.from_checkpoint);
+                if (checkpointIndex >= 0) {
+                    startIndex = checkpointIndex + 1;
+                }
+            }
+            else if (options.from_step) {
+                // Start from the specified step
+                startIndex = orderedSteps.findIndex((s) => s.tag === options.from_step);
+                if (startIndex === -1) {
+                    throw new Error(`Step ${options.from_step} not found`);
+                }
+            }
+            else {
+                // Start after last completed step
+                const lastCompleted = this.state.completed_steps[this.state.completed_steps.length - 1];
+                if (lastCompleted) {
+                    const lastIndex = orderedSteps.findIndex((s) => s.tag === lastCompleted);
+                    startIndex = lastIndex + 1;
+                }
+            }
+            debugLog('[WorkflowExecutor] resume starting from step index', {
+                workflow_id: this.state.workflow_id,
+                startIndex,
+                total_steps: orderedSteps.length,
+                steps_to_run: orderedSteps.slice(startIndex).map((s) => s.tag),
+            });
+            // Execute remaining steps
+            for (let i = startIndex; i < orderedSteps.length; i++) {
+                const step = orderedSteps[i];
+                // Skip if already completed or in skip list
+                if (this.state.completed_steps.includes(step.tag)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (already completed)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                if ((_e = options.skip_steps) === null || _e === void 0 ? void 0 : _e.includes(step.tag)) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (in skip list)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                // Check step condition if present
+                if (step.condition && !(await this.evaluateCondition(step.condition))) {
+                    this.logStepEvent(step, `Step ${step.tag} - skipped (condition not met)`, logs_types_1.LogEventStatus.SUCCESS, { skipped: true });
+                    continue;
+                }
+                this.state.current_step = step.tag;
+                // Log step start
+                this.logStepEvent(step, `Step ${step.tag} - started`, logs_types_1.LogEventStatus.PROCESSING);
+                const result = await this.executeStep(step);
+                // Log step completion
+                this.logStepEvent(step, result.success ? `Step ${step.tag} - completed` : `Step ${step.tag} - failed`, result.success ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, { duration: result.duration, error: result.error });
+                // Step return value = resolved step.output schema with primitive result, or raw when no schema
+                const outputSchemaResume = step.output;
+                const hasOutputSchemaResume = outputSchemaResume && typeof outputSchemaResume === 'object' && !Array.isArray(outputSchemaResume) && Object.keys(outputSchemaResume).length > 0;
+                let stepReturnValueResume = result.output;
+                if (result.success && hasOutputSchemaResume) {
+                    try {
+                        stepReturnValueResume = await this.resolveInput(outputSchemaResume, result.output);
+                    }
+                    catch (_m) {
+                        stepReturnValueResume = result.output;
+                    }
+                }
+                else if (!result.success) {
+                    stepReturnValueResume = undefined;
+                }
+                // Persist step result to backend (use step return shape, not raw primitive)
+                await this.persistStepResult(step, result.success ? types_1.LogEventStatus.SUCCESS : types_1.LogEventStatus.FAIL, stepReturnValueResume, result.error, result.duration, result.input);
+                this.state.step_timings.push({
+                    tag: step.tag,
+                    duration_ms: result.duration,
+                    success: result.success,
+                });
+                if (!result.success) {
+                    this.state.failed_step = step.tag;
+                    // Check if step allows failure
+                    if ((_f = step.options) === null || _f === void 0 ? void 0 : _f.allow_fail) {
+                        this.state.steps[step.tag] = { error: result.error };
+                        continue;
+                    }
+                    // Check if step is optional
+                    if ((_g = step.options) === null || _g === void 0 ? void 0 : _g.optional) {
+                        continue;
+                    }
+                    // Trigger rollback
+                    this.state.status = types_1.WorkflowStatus.ROLLING_BACK;
+                    const rollbackResult = await this.executeRollback(step.tag, result.error || 'Step failed');
+                    await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, result.error);
+                    await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
+                    if (this.graphConnectionUsed) {
+                        await this.getGraphService().disconnect().catch(() => { });
+                        await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                        if (this._brokersService)
+                            await this._brokersService.disconnectAll().catch(() => { });
+                        await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                        await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                        await this.getProcessorService().disconnectSmsClients().catch(() => { });
+                    }
+                    return {
+                        status: types_1.WorkflowStatus.ROLLED_BACK,
+                        workflow_id: this.state.workflow_id,
+                        error: result.error,
+                        execution_time: Date.now() - startTime,
+                        completed_steps: this.state.completed_steps,
+                        step_timings: this.state.step_timings,
+                        failed_step: step.tag,
+                        rollback_info: {
+                            triggered_by: step.tag,
+                            reason: result.error || 'Step failed',
+                            rolled_back_steps: rollbackResult.rolled_back_steps,
+                            failed_rollbacks: rollbackResult.failed_steps,
+                        },
+                    };
+                }
+                // Store step return shape in state (same value we persisted)
+                this.state.steps[step.tag] = stepReturnValueResume;
+                this.state.completed_steps.push(step.tag);
+            }
+            this.state.status = types_1.WorkflowStatus.COMPLETED;
+            this.state.ended_at = Date.now();
+            const output = await this.determineWorkflowOutput();
+            debugLog('[WorkflowExecutor] resume COMPLETED', {
+                workflow_id: this.state.workflow_id,
+                workflow_tag: this.state.workflow_tag,
+                completed_steps: this.state.completed_steps.length,
+                execution_time_ms: Date.now() - startTime,
+            });
+            await this.persistExecutionResult(types_1.LogEventStatus.SUCCESS, output);
+            await ((_j = this.logService) === null || _j === void 0 ? void 0 : _j.publish());
+            if (this.graphConnectionUsed) {
+                await this.getGraphService().disconnect().catch(() => { });
+                await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                if (this._brokersService)
+                    await this._brokersService.disconnectAll().catch(() => { });
+                await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                await this.getProcessorService().disconnectSmsClients().catch(() => { });
+            }
+            return {
+                status: types_1.WorkflowStatus.COMPLETED,
+                workflow_id: this.state.workflow_id,
+                output: output,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                step_timings: this.state.step_timings,
+            };
+        }
+        catch (error) {
+            this.state.status = types_1.WorkflowStatus.FAILED;
+            this.state.ended_at = Date.now();
+            const details = formatErrorDetails(error);
+            const failedAt = (_k = this.state.current_step) !== null && _k !== void 0 ? _k : '(unknown)';
+            debugLog('[WorkflowExecutor] resume FAILED (exception)', Object.assign(Object.assign({ workflow_id: this.state.workflow_id, workflow_tag: this.state.workflow_tag, failed_at: failedAt, completed_steps: this.state.completed_steps, error: details.message }, (details.status != null && { http_status: details.status })), (details.responseBody != null && { response_body: details.responseBody })));
+            if (details.stack) {
+                debugLog('[WorkflowExecutor] resume FAILED stack', details.stack);
+            }
+            const errorSummary = details.status != null
+                ? `Failed at ${failedAt}: ${details.message} (HTTP ${details.status})`
+                : `Failed at ${failedAt}: ${details.message}`;
+            await this.persistExecutionResult(types_1.LogEventStatus.FAIL, undefined, errorSummary);
+            await ((_l = this.logService) === null || _l === void 0 ? void 0 : _l.publish());
+            if (this.graphConnectionUsed) {
+                await this.getGraphService().disconnect().catch(() => { });
+                await this.getProcessorService().disconnectBrokerConnections().catch(() => { });
+                if (this._brokersService)
+                    await this._brokersService.disconnectAll().catch(() => { });
+                await this.getProcessorService().disconnectMailTransporters().catch(() => { });
+                await this.getProcessorService().disconnectFirebaseApps().catch(() => { });
+                await this.getProcessorService().disconnectSmsClients().catch(() => { });
+            }
+            return {
+                status: types_1.WorkflowStatus.FAILED,
+                workflow_id: this.state.workflow_id,
+                error: errorSummary,
+                execution_time: Date.now() - startTime,
+                completed_steps: this.state.completed_steps,
+                step_timings: this.state.step_timings,
+                failed_step: this.state.current_step,
+            };
+        }
+    }
+}
+exports.WorkflowExecutor = WorkflowExecutor;
+/** Comparison operators in parse order (multi-char before single-char). */
+WorkflowExecutor.CONDITION_OP_REGEX = /^\s*(.+?)\s*(!==|===|==|>=|<=|!=|>|<)\s*(.+)\s*$/;
+exports.default = WorkflowExecutor;
+//# sourceMappingURL=workflow-executor.js.map