@ductape/sdk 0.1.7 → 0.1.8

package/dist/workflows/workflows.service.js

@@ -1,2233 +0,0 @@
-"use strict";
-/**
- * Workflow Service
- *
- * Main service class for workflow operations.
- * Provides CRUD operations and execution for Ductape Workflows.
- *
- * Based on Ductape Workflows Code-First API documentation.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.workflowService = exports.WorkflowService = exports.WorkflowError = void 0;
-const crypto_1 = require("crypto");
-const products_service_1 = __importDefault(require("../products/services/products.service"));
-const processor_service_1 = __importDefault(require("../processor/services/processor.service"));
-const workflowApi_service_1 = require("../api/services/workflowApi.service");
-const logs_service_1 = __importDefault(require("../logs/logs.service"));
-const logs_types_1 = require("../logs/logs.types");
-const processor_utils_1 = require("../processor/utils/processor.utils");
-const cache_manager_1 = require("../cache/cache.manager");
-const productsBuilder_types_1 = require("../types/productsBuilder.types");
-const workflow_executor_1 = require("./workflow-executor");
-/**
- * Error class for workflow-related errors
- */
-class WorkflowError extends Error {
-    constructor(message, code, details) {
-        if (typeof window !== 'undefined') {
-            throw new Error('Ductape SDK can only be initialized in a server environment.');
-        }
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'WorkflowError';
-    }
-    static configurationError(message) {
-        return new WorkflowError(message, 'CONFIGURATION_ERROR');
-    }
-    static validationError(message, details) {
-        return new WorkflowError(message, 'VALIDATION_ERROR', details);
-    }
-    static notFoundError(message) {
-        return new WorkflowError(message, 'NOT_FOUND');
-    }
-    static executionError(message, details) {
-        return new WorkflowError(message, 'EXECUTION_ERROR', details);
-    }
-}
-exports.WorkflowError = WorkflowError;
-/**
- * Main Workflow Service class
- * Provides unified interface for workflow management and execution
- */
-class WorkflowService {
-    /**
-     * Create a new WorkflowService instance
-     * @param config - Optional configuration for authentication and workspace context
-     */
-    constructor(config) {
-        /** Service configuration */
-        this.config = null;
-        /** ProductBuilder instances cache (keyed by product tag) */
-        this.productBuilders = new Map();
-        /** Local workflow configurations */
-        this.localConfigs = new Map();
-        /** Workflow API service for backend communication */
-        this.workflowApiService = null;
-        /** LogService instance for logging operations */
-        this.logService = null;
-        /** Current product ID for logging */
-        this.productId = '';
-        /** Cache manager for 3-tier caching */
-        this.cacheManager = null;
-        /** Local cache for cache configurations to avoid repeated API calls */
-        this.cacheConfigCache = new Map();
-        //console.log('[WorkflowService] constructor', { hasConfig: !!config, env_type: config?.env_type, hasRedis: !!config?.redis_client });
-        this.config = config || null;
-        this._privateKey = (config === null || config === void 0 ? void 0 : config.private_key) || '';
-        if (config) {
-            this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
-            console.log('[WorkflowService] WorkflowApiService initialized', { env_type: config.env_type });
-            // Initialize CacheManager if Redis client is provided
-            if (config.redis_client) {
-                this.cacheManager = new cache_manager_1.CacheManager({
-                    workspace_id: config.workspace_id,
-                    public_key: config.public_key,
-                    user_id: config.user_id,
-                    token: config.token,
-                    env_type: config.env_type,
-                    redis_client: config.redis_client,
-                });
-                console.log('[WorkflowService] CacheManager initialized');
-            }
-            else {
-                console.log('[WorkflowService] No redis_client provided, cache disabled');
-            }
-        }
-        else {
-            //console.log('[WorkflowService] No config provided, service unconfigured');
-        }
-    }
-    // ==================== CONFIGURATION ====================
-    /**
-     * Update service configuration
-     */
-    updateConfig(config) {
-        console.log('[WorkflowService] updateConfig', { env_type: config.env_type, workspace_id: config.workspace_id });
-        this.config = config;
-        this.workflowApiService = new workflowApi_service_1.WorkflowApiService(config.env_type);
-    }
-    /**
-     * Get auth payload for API calls
-     */
-    getAuthPayload() {
-        if (!this.config) {
-            console.log('[WorkflowService] getAuthPayload failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        const hasAccessKey = !!this.config.access_key;
-        console.log('[WorkflowService] getAuthPayload', { user_id: this.config.user_id, workspace_id: this.config.workspace_id, hasAccessKey });
-        return Object.assign({ user_id: this.config.user_id, workspace_id: this.config.workspace_id, public_key: this.config.public_key, token: this.config.token }, (this.config.access_key && { access_key: this.config.access_key }));
-    }
-    /**
-     * Ensure WorkflowApiService is initialized
-     */
-    ensureApiService() {
-        if (!this.workflowApiService) {
-            console.log('[WorkflowService] ensureApiService failed: WorkflowApiService not initialized');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        return this.workflowApiService;
-    }
-    /**
-     * Get service configuration
-     */
-    getConfig() {
-        var _a;
-        console.log('[WorkflowService] getConfig', { hasConfig: !!this.config, env_type: (_a = this.config) === null || _a === void 0 ? void 0 : _a.env_type });
-        return this.config;
-    }
-    // ==================== PRODUCT BUILDER MANAGEMENT ====================
-    /**
-     * Create a new ProductBuilder instance
-     */
-    createNewProductBuilder() {
-        if (!this.config) {
-            console.log('[WorkflowService] createNewProductBuilder failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        console.log('[WorkflowService] createNewProductBuilder', { env_type: this.config.env_type, hasAccessKey: !!this.config.access_key });
-        return new products_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,
-            access_key: this.config.access_key,
-            workspace_private_key: this._privateKey || undefined,
-        });
-    }
-    /**
-     * Get or create a ProductBuilder instance for the given product tag
-     */
-    async getProductBuilder(productTag) {
-        let builder = this.productBuilders.get(productTag);
-        if (!builder) {
-            console.log('[WorkflowService] getProductBuilder creating new builder', { productTag });
-            builder = this.createNewProductBuilder();
-            await builder.initializeProductByTag(productTag);
-            this.productBuilders.set(productTag, builder);
-            // Update productId for logging
-            this.productId = builder.fetchProductId() || '';
-            console.log('[WorkflowService] getProductBuilder initialized', { productTag, productId: this.productId });
-        }
-        else {
-            console.log('[WorkflowService] getProductBuilder cache hit', { productTag });
-        }
-        return builder;
-    }
-    /**
-     * Initialize logging service
-     */
-    initializeLogService() {
-        var _a;
-        if (!this.logService && this.config) {
-            console.log('[WorkflowService] initializeLogService', { productId: 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,
-            });
-        }
-    }
-    /**
-     * Validate cache tag exists in product and return cache configuration
-     */
-    async validateCache(productTag, cacheTag) {
-        const cacheKey = `${productTag}:${cacheTag}`;
-        const cached = this.cacheConfigCache.get(cacheKey);
-        const now = Date.now();
-        const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-        console.log('[WorkflowService] validateCache', { productTag, cacheTag, cacheKey, hasCached: !!cached });
-        // Return cached config if still valid
-        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
-            console.log('[WorkflowService] validateCache using cached config', { cacheKey, expiry: cached.expiry });
-            return { expiry: cached.expiry };
-        }
-        // Fetch from API and cache the result
-        const builder = await this.getProductBuilder(productTag);
-        const cache = await builder.fetchCache(cacheTag);
-        if (!cache) {
-            console.log('[WorkflowService] validateCache cache config not found', { cacheTag });
-            throw WorkflowError.validationError(`Cache configuration '${cacheTag}' does not exist`);
-        }
-        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
-        console.log('[WorkflowService] validateCache fetched and cached', { cacheKey, expiry: cache.expiry });
-        return { expiry: cache.expiry };
-    }
-    /**
-     * Create a new ProcessorService instance for job scheduling
-     */
-    createNewProcessor() {
-        if (!this.config) {
-            console.log('[WorkflowService] createNewProcessor failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        console.log('[WorkflowService] createNewProcessor', { env_type: this.config.env_type, hasAccessKey: !!this.config.access_key });
-        return 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,
-        });
-    }
-    // ==================== WORKFLOW CRUD OPERATIONS ====================
-    /**
-     * Create a new workflow from JSON schema
-     *
-     * @example
-     * ```ts
-     * await ductape.workflows.create('my-product', {
-     *   tag: 'order-fulfillment',
-     *   name: 'Order Fulfillment',
-     *   steps: [
-     *     { tag: 'validate', type: 'action', app: 'orders', event: 'validate', input: {} },
-     *     { tag: 'process', type: 'database_action', database: 'orders-db', event: 'create', input: {} },
-     *   ],
-     *   envs: [{ slug: 'prd' }],
-     * });
-     * ```
-     */
-    async create(productTag, workflowData) {
-        var _a, _b, _c;
-        console.log('[WorkflowService] create ENTRY', { productTag, tag: workflowData.tag, name: workflowData.name, stepsCount: (_b = (_a = workflowData.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
-        // Validate required fields
-        if (!workflowData.name || !workflowData.tag || !((_c = workflowData.steps) === null || _c === void 0 ? void 0 : _c.length)) {
-            console.log('[WorkflowService] create validation failed: missing name, tag, or steps');
-            throw WorkflowError.validationError('Workflow requires name, tag, and at least one step');
-        }
-        // Persist to backend using ProductBuilder
-        const builder = await this.getProductBuilder(productTag);
-        console.log('[WorkflowService] create calling builder.createWorkflow', { tag: workflowData.tag });
-        await builder.createWorkflow(workflowData);
-        // Store locally
-        const localConfig = {
-            name: workflowData.name,
-            tag: workflowData.tag,
-            description: workflowData.description,
-            input: workflowData.input,
-            output: workflowData.output,
-            steps: workflowData.steps,
-            signals: workflowData.signals,
-            queries: workflowData.queries,
-            options: workflowData.options,
-            envs: workflowData.envs,
-        };
-        this.localConfigs.set(workflowData.tag, localConfig);
-        console.log('[WorkflowService] create SUCCESS', { productTag, tag: workflowData.tag });
-    }
-    /**
-     * Fetch all workflows for a product
-     *
-     * @example
-     * ```ts
-     * const workflows = await ductape.workflows.fetchAll('my-product');
-     * workflows.forEach(wf => console.log(wf.name, wf.tag));
-     * ```
-     */
-    async fetchAll(productTag) {
-        var _a;
-        console.log('[WorkflowService] fetchAll ENTRY', { productTag });
-        // Return local configs if no product tag
-        if (!productTag) {
-            const localCount = this.localConfigs.size;
-            console.log('[WorkflowService] fetchAll no productTag, returning local configs', { count: localCount });
-            return Array.from(this.localConfigs.values());
-        }
-        // Fetch from API using ProductBuilder
-        try {
-            const builder = await this.getProductBuilder(productTag);
-            console.log('[WorkflowService] fetchAll calling builder.fetchWorkflows', { productTag });
-            const workflows = await builder.fetchWorkflows();
-            // Convert IProductWorkflow[] to IWorkflowConfig[]
-            const result = workflows.map((wf) => this.productWorkflowToConfig(wf));
-            console.log('[WorkflowService] fetchAll SUCCESS', { productTag, count: result.length });
-            return result;
-        }
-        catch (error) {
-            // Fall back to local configs if API fails
-            console.log('[WorkflowService] fetchAll API failed, falling back to local', { productTag, error: (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : error });
-            return Array.from(this.localConfigs.values());
-        }
-    }
-    /**
-     * Fetch a specific workflow by tag
-     *
-     * @example
-     * ```ts
-     * const workflow = await ductape.workflows.fetch('order-fulfillment', 'my-product');
-     * console.log(workflow?.name, workflow?.steps.length);
-     * ```
-     */
-    async fetch(workflowTag, productTag) {
-        var _a, _b;
-        console.log('[WorkflowService] fetch ENTRY', { workflowTag, productTag });
-        // If productTag is provided, fetch from API
-        if (productTag) {
-            try {
-                const builder = await this.getProductBuilder(productTag);
-                console.log('[WorkflowService] fetch calling builder.fetchWorkflow', { workflowTag, productTag });
-                const workflow = await builder.fetchWorkflow(workflowTag);
-                if (workflow) {
-                    const config = this.productWorkflowToConfig(workflow);
-                    // Update local cache
-                    this.localConfigs.set(workflowTag, config);
-                    console.log('[WorkflowService] fetch SUCCESS from API', { workflowTag, productTag, stepsCount: (_a = config.steps) === null || _a === void 0 ? void 0 : _a.length });
-                    return config;
-                }
-                console.log('[WorkflowService] fetch not found on API', { workflowTag, productTag });
-                return null;
-            }
-            catch (error) {
-                // Fall back to local config
-                console.log('[WorkflowService] fetch API failed, trying local', { workflowTag, productTag, error: (_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error });
-                return this.localConfigs.get(workflowTag) || null;
-            }
-        }
-        const local = this.localConfigs.get(workflowTag) || null;
-        console.log('[WorkflowService] fetch from local only', { workflowTag, found: !!local });
-        return local;
-    }
-    /**
-     * Update a workflow
-     *
-     * @example
-     * ```ts
-     * await ductape.workflows.update('order-fulfillment', 'my-product', {
-     *   description: 'Updated description',
-     *   options: { timeout: 3600000 },
-     * });
-     * ```
-     */
-    async update(workflowTag, productTag, updates) {
-        var _a, _b, _c, _d, _e, _f, _g;
-        console.log('[WorkflowService] update ENTRY', { workflowTag, productTag, updateKeys: Object.keys(updates || {}) });
-        // Update in backend
-        const builder = await this.getProductBuilder(productTag);
-        await builder.updateWorkflow(workflowTag, updates);
-        // Update local cache
-        const existing = this.localConfigs.get(workflowTag);
-        if (existing) {
-            const updated = Object.assign(Object.assign({}, existing), { name: updates.name || existing.name, description: (_a = updates.description) !== null && _a !== void 0 ? _a : existing.description, input: (_b = updates.input) !== null && _b !== void 0 ? _b : existing.input, output: (_c = updates.output) !== null && _c !== void 0 ? _c : existing.output, steps: updates.steps || existing.steps, signals: (_d = updates.signals) !== null && _d !== void 0 ? _d : existing.signals, queries: (_e = updates.queries) !== null && _e !== void 0 ? _e : existing.queries, options: (_f = updates.options) !== null && _f !== void 0 ? _f : existing.options, envs: (_g = updates.envs) !== null && _g !== void 0 ? _g : existing.envs });
-            this.localConfigs.set(workflowTag, updated);
-        }
-        console.log('[WorkflowService] update SUCCESS', { workflowTag, productTag });
-    }
-    /**
-     * Delete a workflow
-     *
-     * @example
-     * ```ts
-     * await ductape.workflows.delete('order-fulfillment', 'my-product');
-     * ```
-     */
-    async delete(workflowTag, productTag) {
-        console.log('[WorkflowService] delete ENTRY', { workflowTag, productTag });
-        // Delete from backend
-        const builder = await this.getProductBuilder(productTag);
-        await builder.deleteWorkflow(workflowTag);
-        // Remove from local cache
-        this.localConfigs.delete(workflowTag);
-        console.log('[WorkflowService] delete SUCCESS', { workflowTag, productTag });
-    }
-    // ==================== CODE-FIRST API ====================
-    /**
-     * Define a workflow using the code-first API
-     * Compiles the handler to JSON schema and creates the workflow in one step
-     *
-     * @example
-     * ```ts
-     * const orderWorkflow = await ductape.workflows.define({
-     *   product: 'my-product',
-     *   tag: 'order-fulfillment',
-     *   name: 'Order Fulfillment',
-     *   handler: async (ctx) => {
-     *     const validation = await ctx.step('validate', async () => {
-     *       return ctx.action.run({
-     *         app: 'inventory-service',
-     *         event: 'validate-order',
-     *         input: { body: ctx.input },
-     *       });
-     *     });
-     *
-     *     if (!validation.valid) {
-     *       return { success: false, error: validation.reason };
-     *     }
-     *
-     *     return { success: true };
-     *   },
-     * });
-     * ```
-     */
-    async define(options) {
-        var _a, _b;
-        console.log('[WorkflowService] define ENTRY', { tag: options.tag, name: options.name, product: options.product });
-        // Validate required fields
-        if (!options.tag || !options.name || !options.handler) {
-            console.log('[WorkflowService] define validation failed: missing tag, name, or handler');
-            throw WorkflowError.validationError('Workflow definition requires tag, name, and handler');
-        }
-        // Create a workflow compiler instance
-        const compiler = new WorkflowCompiler(options);
-        // Compile the handler to JSON schema (await so async handler runs and steps are captured)
-        console.log('[WorkflowService] define compiling handler (compileAsync)', { tag: options.tag });
-        const schema = await compiler.compileAsync();
-        console.log('[WorkflowService] define compiled schema', { tag: schema.tag, stepsCount: (_b = (_a = schema.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
-        // If product is specified, create the workflow
-        if (options.product) {
-            console.log('[WorkflowService] define creating workflow on backend', { product: options.product, tag: schema.tag });
-            await this.create(options.product, schema);
-        }
-        // Store locally
-        const localConfig = {
-            name: schema.name,
-            tag: schema.tag,
-            description: schema.description,
-            input: schema.input,
-            output: schema.output,
-            steps: schema.steps,
-            signals: schema.signals,
-            queries: schema.queries,
-            options: schema.options,
-            envs: schema.envs,
-        };
-        this.localConfigs.set(schema.tag, localConfig);
-        console.log('[WorkflowService] define SUCCESS', { tag: options.tag, product: options.product });
-        // Return the defined workflow with compile method
-        return {
-            tag: options.tag,
-            name: options.name,
-            handler: options.handler,
-            compile: () => schema,
-            schema,
-        };
-    }
-    // ==================== WORKFLOW EXECUTION ====================
-    /**
-     * Execute a workflow
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.execute({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   tag: 'order-fulfillment',
-     *   input: {
-     *     order_id: 'ORD-12345',
-     *     items: [{ product_id: 'PROD-1', quantity: 2 }],
-     *   },
-     * });
-     *
-     * console.log(result.status); // 'completed' | 'failed' | 'rolled_back'
-     * console.log(result.output);
-     * ```
-     */
-    async execute(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        console.log('[WorkflowService] execute ENTRY', { product: options.product, env: options.env, tag: options.tag, hasSession: !!options.session, cache: options.cache });
-        if (!this.config) {
-            console.log('[WorkflowService] execute failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        console.log('[WorkflowService] execute process_id', { process_id });
-        // Session log fields (will be populated if session is provided)
-        let sessionLogFields = {};
-        let resolvedOptions = options;
-        // Prefer locally cached workflow (from a recent define()) so step conditions and full schema are preserved
-        const builder = await this.getProductBuilder(options.product);
-        console.log('[WorkflowService] execute fetching workflow', { tag: options.tag, product: options.product });
-        const localConfig = this.localConfigs.get(options.tag);
-        let workflow = localConfig
-            ? Object.assign(Object.assign({}, localConfig), { tag: localConfig.tag, name: localConfig.name, steps: localConfig.steps }) : null;
-        if (workflow) {
-            console.log('[WorkflowService] execute using local workflow config', { tag: options.tag });
-        }
-        if (!workflow) {
-            workflow = await builder.fetchWorkflow(options.tag);
-        }
-        if (!workflow) {
-            console.log('[WorkflowService] execute workflow not found', { tag: options.tag });
-            throw WorkflowError.notFoundError(`Workflow ${options.tag} not found`);
-        }
-        console.log('[WorkflowService] execute workflow loaded', { tag: workflow.tag, stepsCount: (_b = (_a = workflow.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
-        // Process session if provided - verify and resolve $Session{} references
-        if (options.session) {
-            const privateKey = builder.fetchPrivateKey();
-            if (privateKey) {
-                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
-                const sessionResult = await processSessionForExecution(options.session, privateKey, options, options.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await builder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    console.log('[WorkflowService] execute session validation failed', { error: sessionResult.error });
-                    throw WorkflowError.executionError(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedOptions = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-                console.log('[WorkflowService] execute session resolved', { hasLogFields: Object.keys(sessionLogFields).length > 0 });
-            }
-        }
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = Object.assign({ product_tag: options.product, workspace_id: this.config.workspace_id, env: options.env, process_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: options.tag, data: { workflow: options.tag, operation: 'execute' } }, sessionLogFields);
-        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        const { cache } = options;
-        try {
-            // Check cache for idempotency (prevent duplicate executions with same input)
-            if (cache && this.cacheManager && this._privateKey) {
-                console.log('[WorkflowService] execute checking cache', { cache, tag: options.tag });
-                const cacheConfig = await this.validateCache(options.product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.tag,
-                    component_type: 'workflow',
-                    operation: 'execute',
-                    input: { tag: options.tag, input: resolvedOptions.input },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    console.log('[WorkflowService] execute cache HIT', { cache, source: cached.source });
-                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { message: `Workflow execute - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { workflow: options.tag, operation: 'execute', cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
-                    (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
-                    return cached.data;
-                }
-            }
-            // Create and run the workflow executor with resolved options and session context (pass builder to avoid duplicate init)
-            console.log('[WorkflowService] execute creating WorkflowExecutor and running', { tag: options.tag });
-            const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, resolvedOptions, this._privateKey, sessionLogFields, builder);
-            const result = await executor.execute();
-            console.log('[WorkflowService] execute executor completed', { tag: options.tag, status: result === null || result === void 0 ? void 0 : result.status });
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(options.product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: options.product,
-                    component_tag: options.tag,
-                    component_type: 'workflow',
-                    operation: 'execute',
-                    input: { tag: options.tag, input: resolvedOptions.input },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
-            console.log('[WorkflowService] execute SUCCESS', { tag: options.tag, process_id });
-            return result;
-        }
-        catch (error) {
-            console.log('[WorkflowService] execute FAILED', { tag: options.tag, process_id, error: (_h = error === null || error === void 0 ? void 0 : error.message) !== null && _h !== void 0 ? _h : error });
-            (_j = this.logService) === null || _j === void 0 ? void 0 : _j.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - failed', failed_execution: true, data: { workflow: options.tag, operation: 'execute', error: error.message || String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_k = this.logService) === null || _k === void 0 ? void 0 : _k.publish());
-            throw error;
-        }
-    }
-    // ==================== WORKFLOW DISPATCH ====================
-    /**
-     * Dispatch a workflow to run as a scheduled job
-     *
-     * @example
-     * ```ts
-     * // Schedule a workflow to run in 1 hour
-     * const result = await ductape.workflows.dispatch({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow: 'order-fulfillment',
-     *   input: { order_id: 'ORD-123' },
-     *   schedule: { start_at: Date.now() + 3600000 },
-     * });
-     *
-     * // Run on a cron schedule
-     * const result = await ductape.workflows.dispatch({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow: 'daily-report',
-     *   input: {},
-     *   schedule: { cron: '0 0 * * *' }, // Daily at midnight
-     * });
-     * ```
-     */
-    async dispatch(data) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        console.log('[WorkflowService] dispatch ENTRY', { product: data.product, env: data.env, workflow: data.workflow, schedule: !!data.schedule, session: !!data.session, cache: data.cache });
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        const processorService = this.createNewProcessor();
-        const productBuilder = await this.getProductBuilder(data.product);
-        const schedule = data.schedule || {};
-        const startAt = typeof schedule.start_at === 'string' ? new Date(schedule.start_at).getTime() : schedule.start_at || Date.now();
-        // Generate job tag based on workflow
-        const jobTag = `workflow:${data.workflow}`;
-        console.log('[WorkflowService] dispatch jobTag', { jobTag, startAt, cron: schedule.cron, every: schedule.every });
-        // Session log fields (will be populated if session is provided)
-        let sessionLogFields = {};
-        let resolvedData = data;
-        // Process session if provided - verify and resolve $Session{} references
-        if (data.session) {
-            const privateKey = productBuilder.fetchPrivateKey();
-            if (privateKey) {
-                const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
-                const sessionResult = await processSessionForExecution(data.session, privateKey, data, data.env, {
-                    fetchSessionSelector: async (sessionTag) => {
-                        const sessionConfig = await productBuilder.fetchSession(sessionTag);
-                        return sessionConfig === null || sessionConfig === void 0 ? void 0 : sessionConfig.selector;
-                    },
-                });
-                if (sessionResult.error) {
-                    console.log('[WorkflowService] dispatch session validation failed', { error: sessionResult.error });
-                    throw WorkflowError.executionError(`Session validation failed: ${sessionResult.error}`);
-                }
-                resolvedData = sessionResult.input;
-                sessionLogFields = sessionResult.logFields;
-                console.log('[WorkflowService] dispatch session resolved');
-            }
-        }
-        // Initialize logging
-        this.initializeLogService();
-        const baseLogs = Object.assign({ product_tag: data.product, workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '', env: data.env, process_id, type: logs_types_1.LogEventTypes.WORKFLOW, parent_tag: data.workflow, data: { workflow: data.workflow, operation: 'dispatch' } }, sessionLogFields);
-        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        const { cache } = data;
-        try {
-            // Check cache for idempotency (prevent duplicate dispatches with same input)
-            if (cache && this.cacheManager && this._privateKey) {
-                console.log('[WorkflowService] dispatch checking cache', { cache, workflow: data.workflow });
-                const cacheConfig = await this.validateCache(data.product, cache);
-                const cacheOptions = {
-                    cache_tag: cache,
-                    product_tag: data.product,
-                    component_tag: data.workflow,
-                    component_type: 'workflow',
-                    operation: 'dispatch',
-                    input: { workflow: data.workflow, input: data.input, schedule: data.schedule },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                };
-                const cached = await this.cacheManager.fetch(cacheOptions);
-                if (cached.hit && cached.data) {
-                    console.log('[WorkflowService] dispatch cache HIT', { cache, source: cached.source });
-                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: `Workflow dispatch - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { workflow: data.workflow, operation: 'dispatch', cache_source: cached.source }, cache_tag: cache, cache_key: cached.key, cache_status: true }));
-                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
-                    return cached.data;
-                }
-            }
-            // Check if job exists, if not create it
-            console.log('[WorkflowService] dispatch fetching existing job', { jobTag });
-            const existingJob = await productBuilder.fetchJob(jobTag);
-            if (!existingJob) {
-                console.log('[WorkflowService] dispatch job not found, creating', { jobTag });
-                await productBuilder.createJob({
-                    tag: jobTag,
-                    name: `Workflow: ${data.workflow}`,
-                    description: `Auto-created job for workflow ${data.workflow}`,
-                    type: productsBuilder_types_1.JobEventTypes.WORKFLOW, // Use workflow job type
-                    app: data.workflow,
-                    event: 'execute',
-                    executions: 0,
-                    intervals: schedule.every || 0,
-                    start_at: startAt,
-                });
-            }
-            const jobInput = {
-                product: data.product,
-                env: data.env,
-                event: jobTag,
-                input: resolvedData.input,
-                retries: data.retries || 0,
-                start_at: startAt,
-                session: data.session,
-                cache: data.cache,
-                repeat: schedule.cron || schedule.every
-                    ? {
-                        cron: schedule.cron,
-                        every: schedule.every,
-                        limit: schedule.limit,
-                        endDate: schedule.endDate,
-                        tz: schedule.tz,
-                    }
-                    : undefined,
-            };
-            console.log('[WorkflowService] dispatch calling processJob', { jobTag, hasRepeat: !!(schedule.cron || schedule.every) });
-            await processorService.processJob(jobInput);
-            const isRecurring = !!(schedule.cron || schedule.every);
-            console.log('[WorkflowService] dispatch processJob completed', { isRecurring });
-            let nextRunAt;
-            if (isRecurring && schedule.every) {
-                nextRunAt = startAt + schedule.every;
-            }
-            const job_id = (0, crypto_1.randomUUID)();
-            const result = {
-                job_id,
-                status: startAt > Date.now() ? 'scheduled' : 'queued',
-                scheduled_at: startAt,
-                recurring: isRecurring,
-                next_run_at: nextRunAt,
-            };
-            // Store in cache for idempotency (fire-and-forget)
-            if (cache && this.cacheManager && this._privateKey) {
-                const cacheConfig = await this.validateCache(data.product, cache);
-                this.cacheManager.store({
-                    cache_tag: cache,
-                    product_tag: data.product,
-                    component_tag: data.workflow,
-                    component_type: 'workflow',
-                    operation: 'dispatch',
-                    input: { workflow: data.workflow, input: data.input, schedule: data.schedule },
-                    privateKey: this._privateKey,
-                    expiry: cacheConfig.expiry,
-                }, result);
-            }
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - success', successful_execution: true, data: { workflow: data.workflow, operation: 'dispatch', job_id }, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
-            console.log('[WorkflowService] dispatch SUCCESS', { workflow: data.workflow, job_id: result.job_id, status: result.status });
-            return result;
-        }
-        catch (error) {
-            console.log('[WorkflowService] dispatch FAILED', { workflow: data.workflow, error: String(error) });
-            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow dispatch - failed', failed_execution: true, data: { workflow: data.workflow, operation: 'dispatch', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_h = this.logService) === null || _h === void 0 ? void 0 : _h.publish());
-            throw error;
-        }
-    }
-    // ==================== SIGNAL & QUERY ====================
-    /**
-     * Send a signal to a running workflow
-     *
-     * @example
-     * ```ts
-     * await ductape.workflows.signal({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   signal: 'approve',
-     *   payload: { approver_id: 'user-456', comments: 'Approved' },
-     * });
-     * ```
-     */
-    async signal(options) {
-        var _a, _b, _c, _d, _e, _f;
-        console.log('[WorkflowService] signal ENTRY', { workflow_id: options.workflow_id, signal: options.signal, product: options.product, env: options.env });
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        // Initialize logging
-        if (options.product) {
-            await this.getProductBuilder(options.product);
-        }
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: options.product,
-            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
-            env: options.env,
-            process_id,
-            type: logs_types_1.LogEventTypes.WORKFLOW,
-            parent_tag: options.workflow_id,
-            child_tag: options.signal,
-            data: { workflow_id: options.workflow_id, signal: options.signal, operation: 'signal' },
-        };
-        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            const apiService = this.ensureApiService();
-            const auth = this.getAuthPayload();
-            console.log('[WorkflowService] signal calling apiService.sendSignal', { workflow_id: options.workflow_id, signal: options.signal });
-            await apiService.sendSignal(options.workflow_id, {
-                product: options.product,
-                env: options.env,
-                signal: options.signal,
-                payload: options.payload,
-            }, auth);
-            console.log('[WorkflowService] signal SUCCESS', { workflow_id: options.workflow_id, signal: options.signal });
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
-        }
-        catch (error) {
-            console.log('[WorkflowService] signal FAILED', { workflow_id: options.workflow_id, signal: options.signal, error: String(error) });
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow signal - failed', failed_execution: true, data: { workflow_id: options.workflow_id, signal: options.signal, operation: 'signal', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
-            throw error;
-        }
-    }
-    /**
-     * Query a running workflow
-     *
-     * @example
-     * ```ts
-     * const status = await ductape.workflows.query({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   query: 'getStatus',
-     * });
-     *
-     * console.log(status.current_step, status.progress);
-     * ```
-     */
-    async query(options) {
-        console.log('[WorkflowService] query ENTRY', { workflow_id: options.workflow_id, query: options.query, product: options.product, env: options.env });
-        // Query is handled by getting workflow status and extracting query result
-        const status = await this.status({
-            product: options.product,
-            env: options.env,
-            workflow_id: options.workflow_id,
-        });
-        if (!status) {
-            console.log('[WorkflowService] query workflow not found', { workflow_id: options.workflow_id });
-            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
-        }
-        const result = (status.state[options.query] || status);
-        console.log('[WorkflowService] query SUCCESS', { workflow_id: options.workflow_id, query: options.query, hasResult: result !== undefined });
-        // Return the state which contains query results
-        return result;
-    }
-    // ==================== REPLAY, RESTART & RESUME ====================
-    /**
-     * Replay a workflow with the same input
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.replay({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   reason: 'Debugging payment failure',
-     * });
-     * ```
-     */
-    async replay(options) {
-        var _a, _b, _c, _d, _e, _f;
-        console.log('[WorkflowService] replay ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env });
-        const process_id = (0, processor_utils_1.generateObjectId)();
-        if (!this.config) {
-            console.log('[WorkflowService] replay failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        // Initialize logging
-        await this.getProductBuilder(options.product);
-        this.initializeLogService();
-        const baseLogs = {
-            product_tag: options.product,
-            workspace_id: ((_a = this.config) === null || _a === void 0 ? void 0 : _a.workspace_id) || '',
-            env: options.env,
-            process_id,
-            type: logs_types_1.LogEventTypes.WORKFLOW,
-            parent_tag: options.workflow_id,
-            data: { workflow_id: options.workflow_id, operation: 'replay' },
-        };
-        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
-        try {
-            // Get original workflow execution state from backend
-            console.log('[WorkflowService] replay fetching original status', { workflow_id: options.workflow_id });
-            const originalStatus = await this.status({
-                product: options.product,
-                env: options.env,
-                workflow_id: options.workflow_id,
-            });
-            if (!originalStatus) {
-                console.log('[WorkflowService] replay original workflow not found', { workflow_id: options.workflow_id });
-                throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
-            }
-            console.log('[WorkflowService] replay original status', { workflow_tag: originalStatus.workflow_tag, status: originalStatus.status });
-            // Execute with the same input
-            console.log('[WorkflowService] replay executing with same input', { tag: originalStatus.workflow_tag });
-            const result = await this.execute({
-                product: options.product,
-                env: options.env,
-                tag: originalStatus.workflow_tag,
-                input: originalStatus.input || {},
-                idempotency_key: options.idempotency_key,
-            });
-            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
-            console.log('[WorkflowService] replay SUCCESS', { workflow_id: options.workflow_id, replayed_from: options.workflow_id });
-            return Object.assign(Object.assign({}, result), { replayed_from: options.workflow_id });
-        }
-        catch (error) {
-            console.log('[WorkflowService] replay FAILED', { workflow_id: options.workflow_id, error: String(error) });
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow replay - failed', failed_execution: true, data: { workflow_id: options.workflow_id, operation: 'replay', error: String(error) }, status: logs_types_1.LogEventStatus.FAIL }));
-            await ((_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish());
-            throw error;
-        }
-    }
-    /**
-     * Restart a workflow with new or modified input
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.restart({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   input: { email: 'corrected@email.com' },
-     *   reason: 'Customer email was incorrect',
-     * });
-     * ```
-     */
-    async restart(options) {
-        console.log('[WorkflowService] restart ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env, hasInput: !!options.input });
-        if (!this.config) {
-            console.log('[WorkflowService] restart failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        // Get original workflow execution state from backend
-        const originalStatus = await this.status({
-            product: options.product,
-            env: options.env,
-            workflow_id: options.workflow_id,
-        });
-        if (!originalStatus) {
-            console.log('[WorkflowService] restart workflow not found', { workflow_id: options.workflow_id });
-            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
-        }
-        console.log('[WorkflowService] restart original status', { workflow_tag: originalStatus.workflow_tag });
-        // Determine the new input
-        let newInput;
-        if (options.input) {
-            newInput = options.input;
-        }
-        else if (options.input_override && options.merge_input) {
-            newInput = Object.assign(Object.assign({}, (originalStatus.input || {})), options.input_override);
-        }
-        else if (options.input_override) {
-            newInput = options.input_override;
-        }
-        else {
-            newInput = originalStatus.input || {};
-        }
-        // Execute with the new input
-        console.log('[WorkflowService] restart executing with new input', { tag: originalStatus.workflow_tag, inputKeys: Object.keys(newInput || {}) });
-        const result = await this.execute({
-            product: options.product,
-            env: options.env,
-            tag: originalStatus.workflow_tag,
-            input: newInput,
-        });
-        console.log('[WorkflowService] restart SUCCESS', { workflow_id: options.workflow_id, restarted_from: options.workflow_id });
-        return Object.assign(Object.assign({}, result), { restarted_from: options.workflow_id });
-    }
-    /**
-     * Resume a paused or failed workflow from where it stopped
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.resume({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   from_checkpoint: 'payment-complete',
-     * });
-     * ```
-     */
-    async resume(options) {
-        var _a, _b;
-        console.log('[WorkflowService] resume ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env, from_checkpoint: options.from_checkpoint, from_step: options.from_step });
-        if (!this.config) {
-            console.log('[WorkflowService] resume failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        // Get original workflow execution state from backend
-        const originalStatus = await this.status({
-            product: options.product,
-            env: options.env,
-            workflow_id: options.workflow_id,
-        });
-        if (!originalStatus) {
-            console.log('[WorkflowService] resume workflow not found', { workflow_id: options.workflow_id });
-            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
-        }
-        console.log('[WorkflowService] resume original status', { workflow_tag: originalStatus.workflow_tag, completed_steps: (_b = (_a = originalStatus.completed_steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
-        // Fetch the workflow configuration
-        const builder = await this.getProductBuilder(options.product);
-        const workflow = await builder.fetchWorkflow(originalStatus.workflow_tag);
-        if (!workflow) {
-            console.log('[WorkflowService] resume workflow config not found', { tag: originalStatus.workflow_tag });
-            throw WorkflowError.notFoundError(`Workflow ${originalStatus.workflow_tag} not found`);
-        }
-        // Create executor with resume options
-        console.log('[WorkflowService] resume creating executor and resuming', { tag: workflow.tag });
-        const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, {
-            product: options.product,
-            env: options.env,
-            tag: originalStatus.workflow_tag,
-            input: Object.assign(Object.assign({}, (originalStatus.input || {})), (options.input || {})),
-        }, this._privateKey);
-        // Resume execution (executor handles skipping completed steps)
-        const result = await executor.resume({
-            completed_steps: originalStatus.completed_steps,
-            state: originalStatus.state,
-            from_checkpoint: options.from_checkpoint,
-            from_step: options.from_step,
-            skip_steps: options.skip_steps,
-        });
-        console.log('[WorkflowService] resume SUCCESS', { workflow_id: options.workflow_id, resumed_from: options.workflow_id });
-        return Object.assign(Object.assign({}, result), { resumed_from: options.workflow_id, resumed_checkpoint: options.from_checkpoint });
-    }
-    /**
-     * Replay a workflow starting from a specific step
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.replayFromStep({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   from_step: 'process-payment',
-     * });
-     * ```
-     */
-    async replayFromStep(options) {
-        console.log('[WorkflowService] replayFromStep ENTRY', { workflow_id: options.workflow_id, from_step: options.from_step, product: options.product, env: options.env });
-        if (!this.config) {
-            console.log('[WorkflowService] replayFromStep failed: no config');
-            throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
-        }
-        // Get original workflow execution state
-        const originalStatus = await this.status({
-            product: options.product,
-            env: options.env,
-            workflow_id: options.workflow_id,
-        });
-        if (!originalStatus) {
-            console.log('[WorkflowService] replayFromStep workflow not found', { workflow_id: options.workflow_id });
-            throw WorkflowError.notFoundError(`Workflow ${options.workflow_id} not found`);
-        }
-        // Fetch the workflow configuration
-        const builder = await this.getProductBuilder(options.product);
-        const workflow = await builder.fetchWorkflow(originalStatus.workflow_tag);
-        if (!workflow) {
-            console.log('[WorkflowService] replayFromStep workflow config not found', { tag: originalStatus.workflow_tag });
-            throw WorkflowError.notFoundError(`Workflow ${originalStatus.workflow_tag} not found`);
-        }
-        // Find steps before from_step to mark as completed
-        const stepIndex = workflow.steps.findIndex((s) => s.tag === options.from_step);
-        if (stepIndex === -1) {
-            console.log('[WorkflowService] replayFromStep step not found', { from_step: options.from_step });
-            throw WorkflowError.validationError(`Step ${options.from_step} not found in workflow`);
-        }
-        const completedSteps = workflow.steps.slice(0, stepIndex).map((s) => s.tag);
-        console.log('[WorkflowService] replayFromStep stepIndex and completedSteps', { from_step: options.from_step, stepIndex, completedStepsCount: completedSteps.length });
-        // Create executor with partial state
-        const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, {
-            product: options.product,
-            env: options.env,
-            tag: originalStatus.workflow_tag,
-            input: originalStatus.input || {},
-        }, this._privateKey);
-        // Resume from the specified step with overridden outputs
-        const result = await executor.resume({
-            completed_steps: completedSteps,
-            state: originalStatus.state,
-            step_outputs: options.step_outputs,
-        });
-        console.log('[WorkflowService] replayFromStep SUCCESS', { workflow_id: options.workflow_id, from_step: options.from_step });
-        return Object.assign(Object.assign({}, result), { replayed_from: options.workflow_id });
-    }
-    // ==================== STATUS & MANAGEMENT ====================
-    /**
-     * Get the status of a workflow execution
-     *
-     * @example
-     * ```ts
-     * const status = await ductape.workflows.status({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     * });
-     * ```
-     */
-    async status(options) {
-        console.log('[WorkflowService] status ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.getStatus(options.workflow_id, options.product, options.env, auth);
-        if (!response) {
-            console.log('[WorkflowService] status not found', { workflow_id: options.workflow_id });
-            return null;
-        }
-        console.log('[WorkflowService] status SUCCESS', { workflow_id: response.workflow_id, workflow_tag: response.workflow_tag, status: response.status });
-        return {
-            workflow_id: response.workflow_id,
-            workflow_tag: response.workflow_tag,
-            status: response.status,
-            current_step: response.current_step,
-            completed_steps: response.completed_steps,
-            state: response.state,
-            started_at: response.started_at,
-            updated_at: response.updated_at,
-            input: response.input,
-            output: response.output,
-            error: response.error,
-        };
-    }
-    /**
-     * Cancel a running workflow
-     *
-     * @example
-     * ```ts
-     * const result = await ductape.workflows.cancel({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   reason: 'User requested cancellation',
-     * });
-     * ```
-     */
-    async cancel(options) {
-        var _a, _b, _c, _d;
-        console.log('[WorkflowService] cancel ENTRY', {
-            workflow_id: options.workflow_id,
-            product: options.product,
-            env: options.env,
-            reason: options.reason,
-        });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.cancel(options.workflow_id, options.product, options.env, options.reason || 'Cancelled by user', auth);
-        console.log('[WorkflowService] cancel SUCCESS', {
-            workflow_id: options.workflow_id,
-            cancelled: response.cancelled,
-            rolled_back_count: (_b = (_a = response.rolled_back_steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0,
-            failed_rollbacks_count: (_d = (_c = response.failed_rollbacks) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0,
-        });
-        return {
-            cancelled: response.cancelled,
-            rolled_back_steps: response.rolled_back_steps,
-            failed_rollbacks: response.failed_rollbacks,
-        };
-    }
-    /**
-     * Get the execution history of a workflow
-     *
-     * @example
-     * ```ts
-     * const history = await ductape.workflows.history({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     * });
-     * ```
-     */
-    async history(options) {
-        var _a, _b, _c, _d;
-        console.log('[WorkflowService] history ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.getHistory(options.workflow_id, options.product, options.env, auth);
-        console.log('[WorkflowService] history SUCCESS', { workflow_id: response.workflow_id, eventsCount: (_b = (_a = response.events) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0, checkpointsCount: (_d = (_c = response.checkpoints) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0 });
-        return {
-            workflow_id: response.workflow_id,
-            workflow_tag: response.workflow_tag,
-            status: response.status,
-            events: response.events.map((e) => ({
-                type: e.type,
-                timestamp: e.timestamp,
-                data: e.data,
-            })),
-            checkpoints: response.checkpoints,
-            replays: response.replays,
-            restarts: response.restarts,
-        };
-    }
-    /**
-     * Get detailed information about a specific step
-     *
-     * @example
-     * ```ts
-     * const detail = await ductape.workflows.stepDetail({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     *   step_tag: 'process-payment',
-     * });
-     * ```
-     */
-    async stepDetail(options) {
-        console.log('[WorkflowService] stepDetail ENTRY', { workflow_id: options.workflow_id, step_tag: options.step_tag, product: options.product, env: options.env });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.getStepDetail(options.workflow_id, options.step_tag, options.product, options.env, auth);
-        if (!response) {
-            console.log('[WorkflowService] stepDetail not found', { workflow_id: options.workflow_id, step_tag: options.step_tag });
-            return null;
-        }
-        console.log('[WorkflowService] stepDetail SUCCESS', { workflow_id: options.workflow_id, step_tag: response.tag, status: response.status });
-        return {
-            tag: response.tag,
-            name: response.name,
-            status: response.status,
-            input: response.input,
-            output: response.output,
-            error: response.error,
-            attempts: response.attempts,
-            start_time: response.start_time,
-            end_time: response.end_time,
-            duration: response.duration,
-            rollback_status: response.rollback_status,
-            rollback_error: response.rollback_error,
-        };
-    }
-    /**
-     * List all related executions (replays, restarts, resumes)
-     *
-     * @example
-     * ```ts
-     * const related = await ductape.workflows.relatedExecutions({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_id: 'wf-123',
-     * });
-     * ```
-     */
-    async relatedExecutions(options) {
-        var _a, _b;
-        console.log('[WorkflowService] relatedExecutions ENTRY', { workflow_id: options.workflow_id, product: options.product, env: options.env });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.getRelatedExecutions(options.workflow_id, options.product, options.env, auth);
-        console.log('[WorkflowService] relatedExecutions SUCCESS', { workflow_id: options.workflow_id, executionsCount: (_b = (_a = response.executions) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
-        return {
-            original: response.original,
-            executions: response.executions.map((e) => ({
-                workflow_id: e.workflow_id,
-                type: e.type,
-                status: e.status,
-                created_at: e.created_at,
-                replayed_from: e.replayed_from,
-                restarted_from: e.restarted_from,
-                resumed_from: e.resumed_from,
-            })),
-        };
-    }
-    /**
-     * Compare two workflow executions
-     *
-     * @example
-     * ```ts
-     * const comparison = await ductape.workflows.compare({
-     *   product: 'my-product',
-     *   env: 'production',
-     *   workflow_ids: ['wf-123', 'wf-456'],
-     * });
-     * ```
-     */
-    async compare(options) {
-        console.log('[WorkflowService] compare ENTRY', { workflow_ids: options.workflow_ids, product: options.product, env: options.env });
-        const apiService = this.ensureApiService();
-        const auth = this.getAuthPayload();
-        const response = await apiService.compareExecutions(options.workflow_ids, options.product, options.env, auth);
-        console.log('[WorkflowService] compare SUCCESS', { workflow_ids: response.workflows });
-        return {
-            workflows: response.workflows,
-            input_diff: response.input_diff,
-            step_diffs: response.step_diffs,
-            outcome_diff: response.outcome_diff,
-        };
-    }
-    // ==================== HELPER METHODS ====================
-    /**
-     * Convert IProductWorkflow to IWorkflowConfig
-     */
-    productWorkflowToConfig(workflow) {
-        return {
-            name: workflow.name,
-            tag: workflow.tag,
-            description: workflow.description,
-            input: workflow.input,
-            output: workflow.output,
-            steps: workflow.steps,
-            signals: workflow.signals,
-            queries: workflow.queries,
-            options: workflow.options,
-            envs: workflow.envs,
-        };
-    }
-}
-exports.WorkflowService = WorkflowService;
-// ==================== WORKFLOW COMPILER ====================
-/** Symbol to detect workflow input proxy when serializing step input to operator strings */
-const INPUT_PROXY_SYMBOL = Symbol.for('RecordingContext.inputProxy');
-/** Symbol to detect step result proxy (values are already operator strings) */
-const STEP_RESULT_PROXY_SYMBOL = Symbol.for('RecordingContext.stepResultProxy');
-/** Symbol on step result proxy to get the operator string (for nested result paths) */
-const STEP_RESULT_REF_STRING = Symbol.for('RecordingContext.stepResultRefString');
-/** Symbol on component result proxy so step return shape uses $StepOutput{path} at runtime */
-const STEP_OUTPUT_REF_STRING = Symbol.for('RecordingContext.stepOutputRefString');
-/**
- * Create a proxy for ctx.input so that ctx.input.field compiles to $Input{field}.
- * When the whole proxy is used as a value (e.g. body: ctx.input), it is replaced
- * with an object of $Input{key} for each key in the workflow input schema.
- */
-function createInputProxy(schemaKeys) {
-    const refs = Object.fromEntries(schemaKeys.map((k) => [k, `$Input{${k}}`]));
-    const proxy = new Proxy(refs, {
-        get(target, prop) {
-            if (prop === INPUT_PROXY_SYMBOL)
-                return true;
-            if (typeof prop === 'string' && prop in target)
-                return target[prop];
-            return `$Input{${String(prop)}}`;
-        },
-    });
-    proxy[INPUT_PROXY_SYMBOL] = true;
-    return proxy;
-}
-/**
- * Create a proxy for a step result so that result.field compiles to $Sequence{main}{stepTag}{field}.
- * Supports nested paths: result.data.nested.foo → $Sequence{main}{stepTag}{data.nested.foo}.
- * When a property is read, recordUsage(stepTag) is called so depends_on can be inferred.
- */
-function createStepResultProxy(workflowTag, stepTag, pathPrefix = '', recordUsage) {
-    const refString = pathPrefix ? `$Sequence{main}{${stepTag}}{${pathPrefix}}` : undefined;
-    return new Proxy({}, {
-        get(_, prop) {
-            if (prop === STEP_RESULT_PROXY_SYMBOL)
-                return true;
-            if (prop === STEP_RESULT_REF_STRING)
-                return refString;
-            // So template literals like `${paymentResult.transactionId}` get the operator string
-            if (prop === Symbol.toPrimitive) {
-                return (hint) => (hint === 'string' && refString ? refString : undefined);
-            }
-            if (prop === 'toString' || prop === 'valueOf') {
-                return () => refString !== null && refString !== void 0 ? refString : '';
-            }
-            if (typeof prop === 'string') {
-                recordUsage === null || recordUsage === void 0 ? void 0 : recordUsage(stepTag);
-            }
-            const fullPath = pathPrefix ? `${pathPrefix}.${String(prop)}` : String(prop);
-            return createStepResultProxy(workflowTag, stepTag, fullPath, recordUsage);
-        },
-    });
-}
-/**
- * Create a proxy for the current step's component result (e.g. storage.upload return).
- * Any property access compiles to $StepOutput{path} so the step's return shape is resolved at runtime from the primitive result.
- * Supports nested paths: proxy.data.id → $StepOutput{data.id}.
- */
-function createStepOutputProxy(pathPrefix = '') {
-    return new Proxy({}, {
-        get(_, prop) {
-            if (prop === STEP_OUTPUT_REF_STRING)
-                return pathPrefix ? `$StepOutput{${pathPrefix}}` : undefined;
-            const fullPath = pathPrefix ? `${pathPrefix}.${String(prop)}` : String(prop);
-            return createStepOutputProxy(fullPath);
-        },
-    });
-}
-/**
- * Recursively convert recorded step input to operator strings per Ductape operator docs.
- * - Replaces input-proxy values with { key: '$Input{key}', ... } for all workflow input keys.
- * - Leaves values that are already operator strings (e.g. from step result proxy) as-is.
- * - Strings containing operator refs ($Input{...}, $Sequence{main}{...}{...}, $Now) are converted to $Concat([...], "").
- * - Default delimiter is "" so template literals like `receipts/${ctx.input.orderId}.txt` become receipts/ORD-001.txt not receipts/ ORD-001 .txt.
- * - Recurses into plain objects and arrays; leaves other primitives unchanged.
- */
-const OPERATOR_REF_IN_STRING_REGEX = /(\$Input\{[^}]+\}|\$Sequence\{main\}\{[^}]+\}\{[^}]*\}|\$Now)/g;
-function convertStringToConcatIfOperatorRefs(str, delimiter = '') {
-    OPERATOR_REF_IN_STRING_REGEX.lastIndex = 0;
-    const tokens = str.split(OPERATOR_REF_IN_STRING_REGEX);
-    const parts = [];
-    for (const t of tokens) {
-        if (!t)
-            continue;
-        const isOp = t.startsWith('$Input{') || t.startsWith('$Sequence{') || t === '$Now';
-        if (isOp) {
-            parts.push(t);
-        }
-        else {
-            const trimmed = t.trim();
-            if (trimmed.length > 0)
-                parts.push(trimmed);
-        }
-    }
-    if (parts.length <= 1)
-        return str;
-    return `$Concat([${parts.map((s) => (s.startsWith('$') ? s : JSON.stringify(s))).join(', ')}], "${delimiter.replace(/"/g, '\\"')}")`;
-}
-function convertToOperatorInput(value, inputProxy, schemaKeys) {
-    if (value === null || value === undefined)
-        return value;
-    if (inputProxy && value === inputProxy) {
-        return Object.fromEntries(schemaKeys.map((k) => [k, `$Input{${k}}`]));
-    }
-    const v = value;
-    if (typeof v === 'object' && v !== null && v[INPUT_PROXY_SYMBOL] === true) {
-        return Object.fromEntries(schemaKeys.map((k) => [k, `$Input{${k}}`]));
-    }
-    // Step result proxy (including nested result.data.foo) exposes operator string via STEP_RESULT_REF_STRING
-    if (typeof v === 'object' && v !== null && typeof v[STEP_RESULT_REF_STRING] === 'string') {
-        return v[STEP_RESULT_REF_STRING];
-    }
-    // Component result proxy (current step's primitive return) so step.output gets $StepOutput{path}
-    if (typeof v === 'object' && v !== null && typeof v[STEP_OUTPUT_REF_STRING] === 'string') {
-        return v[STEP_OUTPUT_REF_STRING];
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => convertToOperatorInput(item, inputProxy, schemaKeys));
-    }
-    if (typeof value === 'object' && value !== null && !(value instanceof Date)) {
-        const out = {};
-        for (const key of Object.keys(value)) {
-            out[key] = convertToOperatorInput(value[key], inputProxy, schemaKeys);
-        }
-        return out;
-    }
-    if (typeof value === 'string') {
-        return convertStringToConcatIfOperatorRefs(value);
-    }
-    return value;
-}
-/**
- * Recording context that captures step definitions during handler execution.
- * Uses operator strings ($Input{field}, $Sequence{main}{stepTag}{field}) per Ductape operator docs.
- */
-/** Build a step condition from a branch override so the step only runs when the overridden step's output matches (e.g. $Step{validate}{valid} == true). */
-function buildConditionFromOverride(stepTag, override) {
-    if (override === null || override === undefined)
-        return '';
-    if (typeof override !== 'object' || Array.isArray(override)) {
-        return `$Step{${stepTag}}{value} == ${JSON.stringify(override)}`;
-    }
-    const parts = [];
-    for (const [key, val] of Object.entries(override)) {
-        if (typeof val !== 'object' || val === null || Array.isArray(val)) {
-            parts.push(`$Step{${stepTag}}{${key}} == ${JSON.stringify(val)}`);
-        }
-    }
-    return parts.length === 0 ? '' : parts.join(' && ');
-}
-/** Build a step condition from a scenario (recordInput) so the step only runs when workflow input matches (e.g. $Input{type} == 'a'). */
-function buildConditionFromScenario(scenario) {
-    const parts = [];
-    for (const [key, val] of Object.entries(scenario)) {
-        if (val !== undefined && (typeof val !== 'object' || val === null || Array.isArray(val))) {
-            parts.push(`$Input{${key}} == ${JSON.stringify(val)}`);
-        }
-    }
-    return parts.length === 0 ? '' : parts.join(' && ');
-}
-/** Create ctx.input that prefers recordInput values (for loops/switch) and falls back to $Input{field} for other keys. */
-function createHybridInputProxy(recordInput, inputProxy) {
-    const base = recordInput !== null && recordInput !== void 0 ? recordInput : {};
-    if (!inputProxy)
-        return base;
-    return new Proxy(base, {
-        get(target, prop) {
-            if (typeof prop !== 'string')
-                return target[prop];
-            if (prop in target && target[prop] !== undefined) {
-                return target[prop];
-            }
-            return inputProxy[prop];
-        },
-        has(target, prop) {
-            return prop in target || (inputProxy && prop in inputProxy);
-        },
-    });
-}
-class RecordingContext {
-    constructor(_input, workflowTag, workflowInputSchema, stepResultOverrides, scenarioCondition, recordInput) {
-        this._steps = [];
-        this._stepOrder = 0;
-        this._currentStepTag = null;
-        /** Step being built for the current ctx.step() call; updated in place by _updateCurrentStep so we emit one step per ctx.step(). */
-        this._pendingStep = null;
-        this._pendingRollback = null;
-        this._inputProxy = null;
-        /** Step tags whose result was read during the current step (for inferring depends_on) */
-        this._stepResultDependencies = new Set();
-        /** When set, the next step we push gets this condition (from a prior step's branch override). */
-        this._pendingConditionFromOverride = null;
-        this._stepResultOverrides = {};
-        /** When set (from recordScenarios), every step we push gets this condition so it only runs when input matches. */
-        this._scenarioCondition = null;
-        this._recordInput = null;
-        this._hybridInput = null;
-        this._workflowTag = workflowTag;
-        this._inputSchemaKeys = workflowInputSchema ? Object.keys(workflowInputSchema) : [];
-        this._stepResultOverrides = stepResultOverrides !== null && stepResultOverrides !== void 0 ? stepResultOverrides : {};
-        this._scenarioCondition = scenarioCondition !== null && scenarioCondition !== void 0 ? scenarioCondition : null;
-        this._recordInput = recordInput !== null && recordInput !== void 0 ? recordInput : null;
-        if (this._inputSchemaKeys.length > 0) {
-            this._inputProxy = createInputProxy(this._inputSchemaKeys);
-        }
-        this._hybridInput = createHybridInputProxy(this._recordInput, this._inputProxy);
-    }
-    // Readonly workflow metadata — prefer recordInput for control flow (loops, switch), fall back to $Input{field}
-    get input() {
-        var _a, _b;
-        return ((_b = (_a = this._hybridInput) !== null && _a !== void 0 ? _a : this._inputProxy) !== null && _b !== void 0 ? _b : {});
-    }
-    get workflow_id() {
-        return `compile-${this._workflowTag}`;
-    }
-    get workflow_tag() {
-        return this._workflowTag;
-    }
-    get env() {
-        return 'compile';
-    }
-    get product() {
-        return 'compile';
-    }
-    get context() {
-        return {};
-    }
-    get state() {
-        return {};
-    }
-    get steps() {
-        return {};
-    }
-    get completed_steps() {
-        return [];
-    }
-    get current_step() {
-        return this._currentStepTag;
-    }
-    /** At record time returns "$Now" so template literals like `at ${ctx.now()}` compile to $Concat(..., "$Now"). */
-    get now() {
-        return '$Now';
-    }
-    /**
-     * Record a step definition
-     */
-    async step(tag, handler, rollback, options) {
-        this._currentStepTag = tag;
-        this._stepOrder++;
-        this._stepResultDependencies = new Set();
-        // Create step placeholder - will be updated in place by component calls (_updateCurrentStep)
-        const step = {
-            tag,
-            name: tag,
-            type: productsBuilder_types_1.WorkflowStepType.ACTION,
-            event: '',
-            input: {},
-            options,
-        };
-        this._pendingStep = step;
-        // Execute handler to capture component calls and step return value
-        let stepReturn;
-        try {
-            stepReturn = await handler();
-        }
-        catch (e) {
-            // Ignore errors during compilation - we're just tracing
-        }
-        this._pendingStep = null;
-        // Parse and store step output in schema (operator strings for downstream $Step{tag}{field} references)
-        const valueToCapture = stepReturn !== undefined && stepReturn !== null && typeof stepReturn === 'object' && !Array.isArray(stepReturn)
-            ? stepReturn.output !== undefined && stepReturn.process_id !== undefined
-                ? stepReturn.output
-                : stepReturn
-            : stepReturn;
-        if (valueToCapture !== undefined && valueToCapture !== null && typeof valueToCapture === 'object' && !Array.isArray(valueToCapture)) {
-            step.output = convertToOperatorInput(valueToCapture, this._inputProxy, this._inputSchemaKeys);
-        }
-        else if (valueToCapture !== undefined && valueToCapture !== null) {
-            step.output = { value: convertToOperatorInput(valueToCapture, this._inputProxy, this._inputSchemaKeys) };
-        }
-        else {
-            step.output = {};
-        }
-        // If rollback was provided, try to capture it
-        if (rollback && this._pendingRollback) {
-            step.rollback = this._pendingRollback;
-            this._pendingRollback = null;
-        }
-        // Always add the step (even when no component was called — e.g. validate-order that only returns)
-        if (!step.event) {
-            step.event = step.tag;
-        }
-        if (this._stepResultDependencies.size > 0) {
-            step.depends_on = Array.from(this._stepResultDependencies);
-        }
-        // Apply conditions: scenario (e.g. $Input{type} == 'a') and/or branch override (e.g. $Step{validate}{valid} == true)
-        const condParts = [];
-        if (this._scenarioCondition)
-            condParts.push(`(${this._scenarioCondition})`);
-        if (this._pendingConditionFromOverride) {
-            condParts.push(`(${this._pendingConditionFromOverride})`);
-            this._pendingConditionFromOverride = null;
-        }
-        if (condParts.length > 0)
-            step.condition = condParts.join(' && ');
-        const overrideForThisStep = this._stepResultOverrides[tag];
-        if (overrideForThisStep !== undefined) {
-            this._pendingConditionFromOverride = buildConditionFromOverride(tag, overrideForThisStep);
-        }
-        this._steps.push(step);
-        this._currentStepTag = null;
-        // When branchOverrides[tag] is set, return it so the handler continues past if (!result.x) return (records both branches)
-        if (overrideForThisStep !== undefined) {
-            return overrideForThisStep;
-        }
-        // Return step-result proxy so result.field compiles to $Sequence{main}{stepTag}{field}
-        const recordUsage = (depTag) => this._stepResultDependencies.add(depTag);
-        return createStepResultProxy(this._workflowTag, step.tag, '', recordUsage);
-    }
-    // ==================== COMPONENT CONTEXTS ====================
-    get action() {
-        return {
-            run: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.ACTION, options.action, {
-                    app: options.app,
-                    input: options.input,
-                    options: { retries: options.retries, timeout: options.timeout },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get database() {
-        return {
-            execute: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
-                    database: options.database,
-                    input: options.input,
-                    options: { retries: options.retries, timeout: options.timeout },
-                });
-                return createStepOutputProxy();
-            },
-            query: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
-                    database: options.database,
-                    input: options.params || {},
-                });
-                return createStepOutputProxy();
-            },
-            insert: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
-                    database: options.database,
-                    input: { table: options.table, data: options.data },
-                });
-                return createStepOutputProxy();
-            },
-            update: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
-                    database: options.database,
-                    input: { table: options.table, data: options.data, where: options.where },
-                });
-                return createStepOutputProxy();
-            },
-            delete: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
-                    database: options.database,
-                    input: { table: options.table, where: options.where },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get graph() {
-        return {
-            execute: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, options.action, {
-                    graph: options.graph,
-                    input: options.input,
-                });
-                return createStepOutputProxy();
-            },
-            createNode: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'createNode', {
-                    graph: options.graph,
-                    input: { labels: options.labels, properties: options.properties },
-                });
-                return createStepOutputProxy();
-            },
-            updateNode: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'updateNode', {
-                    graph: options.graph,
-                    input: { id: options.id, properties: options.properties },
-                });
-                return createStepOutputProxy();
-            },
-            deleteNode: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'deleteNode', {
-                    graph: options.graph,
-                    input: { id: options.id },
-                });
-                return createStepOutputProxy();
-            },
-            createRelationship: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'createRelationship', {
-                    graph: options.graph,
-                    input: { from: options.from, to: options.to, type: options.type, properties: options.properties },
-                });
-                return createStepOutputProxy();
-            },
-            deleteRelationship: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, 'deleteRelationship', {
-                    graph: options.graph,
-                    input: { id: options.id },
-                });
-                return createStepOutputProxy();
-            },
-            query: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.GRAPH, options.action, {
-                    graph: options.graph,
-                    input: options.params || {},
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get notification() {
-        return {
-            send: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
-                    notification: options.notification,
-                    input: options.input,
-                    options: { retries: options.retries },
-                });
-                return createStepOutputProxy();
-            },
-            email: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
-                    notification: options.notification,
-                    input: { recipients: options.recipients, subject: options.subject, template: options.template },
-                });
-                return createStepOutputProxy();
-            },
-            push: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
-                    notification: options.notification,
-                    input: { tokens: options.tokens, title: options.title, body: options.body, data: options.data },
-                });
-                return createStepOutputProxy();
-            },
-            sms: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.NOTIFICATION, options.event, {
-                    notification: options.notification,
-                    input: { phones: options.phones, message: options.message },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get storage() {
-        return {
-            upload: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
-                    storage: options.storage,
-                    input: options.input,
-                    options: { retries: options.retries },
-                });
-                return createStepOutputProxy();
-            },
-            download: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
-                    storage: options.storage,
-                    input: options.input,
-                });
-                return createStepOutputProxy();
-            },
-            delete: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.STORAGE, options.event, {
-                    storage: options.storage,
-                    input: options.input,
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    /** Ductape primitive: message broker produce. Records a produce step (event = "broker-tag:topic-tag"). */
-    get messaging() {
-        return {
-            produce: async (options) => {
-                const colon = options.event.indexOf(':');
-                const broker = colon >= 0 ? options.event.slice(0, colon) : options.event;
-                const topic = colon >= 0 ? options.event.slice(colon + 1) : options.event;
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.PRODUCE, topic, {
-                    broker,
-                    input: { message: options.message },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    /** @deprecated Prefer ctx.messaging.produce() */
-    get publish() {
-        return {
-            send: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.PRODUCE, options.event, {
-                    broker: options.broker,
-                    input: options.input,
-                    options: { retries: options.retries },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get feature() {
-        return {
-            run: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.FEATURE, options.feature, {
-                    input: options.input,
-                    options: { retries: options.retries, timeout: options.timeout },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get quota() {
-        return {
-            execute: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.QUOTA, 'execute', {
-                    quota: options.quota,
-                    input: options.input,
-                    options: { timeout: options.timeout },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get fallback() {
-        return {
-            execute: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.FALLBACK, 'execute', {
-                    fallback: options.fallback,
-                    input: options.input,
-                    options: { timeout: options.timeout },
-                });
-                return createStepOutputProxy();
-            },
-        };
-    }
-    get healthcheck() {
-        return {
-            getStatus: async (tag) => {
-                return { status: 'available', lastChecked: new Date().toISOString(), lastLatency: 0 };
-            },
-        };
-    }
-    get transform() {
-        return {
-            size: (obj) => Object.keys(obj).length,
-            length: (arr) => arr.length,
-            parseJson: (str) => JSON.parse(str),
-            stringify: (obj) => JSON.stringify(obj),
-            upper: (str) => str.toUpperCase(),
-            lower: (str) => str.toLowerCase(),
-            trim: (str) => str.trim(),
-            split: (str, separator) => str.split(separator),
-            join: (arr, separator) => arr.join(separator),
-            now: () => Date.now(),
-            formatDate: (date, format) => new Date(date).toISOString(),
-        };
-    }
-    // ==================== DATA REFERENCES ====================
-    variable(app, key) {
-        return `$Variable{${app}}{${key}}`;
-    }
-    constant(app, key) {
-        return `$Constant{${app}}{${key}}`;
-    }
-    token(key) {
-        return `$Secret{${key}}`;
-    }
-    get auth() {
-        return {};
-    }
-    default(value, fallback) {
-        return value !== null && value !== void 0 ? value : fallback;
-    }
-    // ==================== CONTROL FLOW ====================
-    async sleep(duration) {
-        const ms = typeof duration === 'string' ? this._parseDuration(duration) : duration;
-        this._addControlStep(productsBuilder_types_1.WorkflowStepType.SLEEP, 'sleep', { duration: ms });
-    }
-    async waitForSignal(signal, options) {
-        const signals = Array.isArray(signal) ? signal : [signal];
-        const timeout = (options === null || options === void 0 ? void 0 : options.timeout)
-            ? typeof options.timeout === 'string'
-                ? this._parseDuration(options.timeout)
-                : options.timeout
-            : undefined;
-        this._addControlStep(productsBuilder_types_1.WorkflowStepType.WAIT_FOR_SIGNAL, signals[0], {
-            signals,
-            options: timeout ? { timeout } : undefined,
-        });
-        return {};
-    }
-    async checkpoint(name, metadata) {
-        this._addControlStep(productsBuilder_types_1.WorkflowStepType.CHECKPOINT, name, { metadata });
-    }
-    // ==================== STATE MANAGEMENT ====================
-    setState(key, value) {
-        // No-op during compilation
-    }
-    getState(key) {
-        return undefined;
-    }
-    // ==================== LOGGING ====================
-    get log() {
-        return {
-            debug: (message, data) => { },
-            info: (message, data) => { },
-            warn: (message, data) => { },
-            error: (message, data) => { },
-        };
-    }
-    // ==================== CHILD WORKFLOWS ====================
-    async workflow(childId, tag, input, options) {
-        this._addControlStep(productsBuilder_types_1.WorkflowStepType.CHILD_WORKFLOW, 'execute', {
-            workflow: tag,
-            input,
-            options: options
-                ? {
-                    timeout: options.timeout
-                        ? typeof options.timeout === 'string'
-                            ? this._parseDuration(options.timeout)
-                            : options.timeout
-                        : undefined,
-                    retries: options.retries,
-                }
-                : undefined,
-        });
-        return {};
-    }
-    // ==================== ROLLBACK ====================
-    async triggerRollback(reason) {
-        return { success: true, rolled_back_steps: [], reason };
-    }
-    // ==================== INTERNAL HELPERS ====================
-    _updateCurrentStep(type, event, data) {
-        if (!this._currentStepTag)
-            return;
-        // Update the step we're currently building (one step per ctx.step()), so we don't duplicate
-        const step = this._pendingStep && this._pendingStep.tag === this._currentStepTag
-            ? this._pendingStep
-            : this._steps.find((s) => s.tag === this._currentStepTag);
-        if (!step) {
-            const newStep = {
-                tag: this._currentStepTag,
-                type,
-                event,
-                input: data.input || {},
-            };
-            this._steps.push(newStep);
-            this._updateStepProperties(newStep, type, event, data);
-            return;
-        }
-        this._updateStepProperties(step, type, event, data);
-    }
-    _updateStepProperties(step, type, event, data) {
-        // Update step properties
-        step.type = type;
-        step.event = event;
-        if (data.app)
-            step.app = data.app;
-        if (data.database)
-            step.database = data.database;
-        if (data.graph)
-            step.graph = data.graph;
-        if (data.storage)
-            step.storage = data.storage;
-        if (data.notification)
-            step.notification = data.notification;
-        if (data.broker)
-            step.broker = data.broker;
-        if (data.quota)
-            step.quota = data.quota;
-        if (data.fallback)
-            step.fallback = data.fallback;
-        if (data.workflow)
-            step.workflow = data.workflow;
-        if (data.input) {
-            step.input = convertToOperatorInput(data.input, this._inputProxy, this._inputSchemaKeys);
-        }
-        if (data.options)
-            step.options = Object.assign(Object.assign({}, step.options), data.options);
-    }
-    _addControlStep(type, event, data) {
-        const tag = `${type}-${this._stepOrder++}`;
-        const input = convertToOperatorInput(data, this._inputProxy, this._inputSchemaKeys);
-        const step = {
-            tag,
-            type,
-            event,
-            input,
-        };
-        if (data.workflow != null)
-            step.workflow = data.workflow;
-        if (data.options != null)
-            step.options = data.options;
-        this._steps.push(step);
-    }
-    _parseDuration(duration) {
-        const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
-        if (!match)
-            return parseInt(duration, 10) || 0;
-        const value = parseInt(match[1], 10);
-        const unit = match[2];
-        switch (unit) {
-            case 'ms':
-                return value;
-            case 's':
-                return value * 1000;
-            case 'm':
-                return value * 60 * 1000;
-            case 'h':
-                return value * 60 * 60 * 1000;
-            case 'd':
-                return value * 24 * 60 * 60 * 1000;
-            default:
-                return value;
-        }
-    }
-    /** Convert a value (e.g. handler return) to operator form for workflow output schema */
-    captureOutput(value) {
-        if (value === undefined || value === null)
-            return {};
-        const converted = convertToOperatorInput(value, this._inputProxy, this._inputSchemaKeys);
-        if (typeof converted === 'object' && converted !== null && !Array.isArray(converted)) {
-            return converted;
-        }
-        return { value: converted };
-    }
-    /** Get collected steps */
-    getSteps() {
-        return this._steps;
-    }
-}
-/**
- * Compiles code-first workflow definitions to JSON schema
- * Uses runtime handler tracing to capture step definitions
- */
-class WorkflowCompiler {
-    constructor(options) {
-        this.options = options;
-    }
-    /**
-     * Compile the workflow definition to JSON schema
-     * Executes the handler with a recording context to capture step definitions
-     */
-    compile() {
-        var _a, _b, _c, _d;
-        const mockInput = ((_a = this.options.recordInput) !== null && _a !== void 0 ? _a : {});
-        const recordingCtx = new RecordingContext(mockInput, this.options.tag, this.options.input, this.options.branchOverrides, undefined, ((_b = this.options.recordInput) !== null && _b !== void 0 ? _b : {}));
-        // Execute handler to trace step definitions
-        try {
-            // Run the handler synchronously to capture all step calls
-            // Note: This won't await async operations, but will capture the step structure
-            const handlerPromise = this.options.handler(recordingCtx);
-            // For synchronous tracing, we don't need to await
-            // The recording context captures calls as they're made
-            if (handlerPromise && typeof handlerPromise.then === 'function') {
-                // Handler is async - we capture what we can synchronously
-                // For full async tracing, use compileAsync()
-            }
-        }
-        catch (e) {
-            // Ignore errors during compilation - we're tracing structure, not executing
-        }
-        return {
-            name: this.options.name,
-            tag: this.options.tag,
-            description: this.options.description,
-            input: (_c = this.options.input) !== null && _c !== void 0 ? _c : {},
-            output: (_d = this.options.output) !== null && _d !== void 0 ? _d : {},
-            steps: recordingCtx.getSteps(),
-            signals: this.options.signals
-                ? Object.fromEntries(Object.entries(this.options.signals).map(([name, config]) => [name, { name, input: config.input }]))
-                : undefined,
-            queries: this.options.queries
-                ? Object.fromEntries(Object.entries(this.options.queries).map(([name, config]) => {
-                    var _a;
-                    return [
-                        name,
-                        { name, handler: (_a = config.handler) === null || _a === void 0 ? void 0 : _a.toString() },
-                    ];
-                }))
-                : undefined,
-            options: this.options.options,
-            envs: this.options.envs,
-        };
-    }
-    /**
-     * Compile the workflow definition asynchronously
-     * Fully awaits the handler to capture all step definitions.
-     * With recordScenarios, runs the handler once per scenario and merges steps (for switch-style branches).
-     * With recordInput, uses that as ctx.input so loops and control flow see real values.
-     */
-    async compileAsync() {
-        var _a, _b, _c, _d;
-        const scenarios = this.options.recordScenarios && this.options.recordScenarios.length > 0
-            ? this.options.recordScenarios
-            : [(_a = this.options.recordInput) !== null && _a !== void 0 ? _a : {}];
-        const stepsByTag = new Map();
-        const stepOrder = [];
-        let handlerOutput = undefined;
-        let lastCtx = null;
-        for (const scenario of scenarios) {
-            const scenarioObj = typeof scenario === 'object' && scenario !== null ? scenario : {};
-            const scenarioCondition = this.options.recordScenarios && Object.keys(scenarioObj).length > 0
-                ? buildConditionFromScenario(scenarioObj)
-                : null;
-            const recordInput = Object.keys(scenarioObj).length > 0
-                ? scenarioObj
-                : ((_b = this.options.recordInput) !== null && _b !== void 0 ? _b : {});
-            const recordingCtx = new RecordingContext((recordInput !== null && recordInput !== void 0 ? recordInput : {}), this.options.tag, this.options.input, this.options.branchOverrides, scenarioCondition, recordInput);
-            lastCtx = recordingCtx;
-            try {
-                const out = await this.options.handler(recordingCtx);
-                if (out !== undefined && out !== null)
-                    handlerOutput = out;
-            }
-            catch (_) { }
-            for (const s of recordingCtx.getSteps()) {
-                const existing = stepsByTag.get(s.tag);
-                if (existing) {
-                    const c1 = existing.condition;
-                    const c2 = s.condition;
-                    if (c1 && c2)
-                        existing.condition = `(${c1}) || (${c2})`;
-                    else if (c2)
-                        existing.condition = c2;
-                }
-                else {
-                    stepsByTag.set(s.tag, Object.assign({}, s));
-                    stepOrder.push(s.tag);
-                }
-            }
-        }
-        const finalSteps = stepOrder.map((tag) => stepsByTag.get(tag)).filter(Boolean);
-        const output = handlerOutput !== undefined && handlerOutput !== null && lastCtx
-            ? lastCtx.captureOutput(handlerOutput)
-            : ((_c = this.options.output) !== null && _c !== void 0 ? _c : {});
-        return {
-            name: this.options.name,
-            tag: this.options.tag,
-            description: this.options.description,
-            input: (_d = this.options.input) !== null && _d !== void 0 ? _d : {},
-            output: output,
-            steps: finalSteps,
-            signals: this.options.signals
-                ? Object.fromEntries(Object.entries(this.options.signals).map(([name, config]) => [name, { name, input: config.input }]))
-                : undefined,
-            queries: this.options.queries
-                ? Object.fromEntries(Object.entries(this.options.queries).map(([name, config]) => {
-                    var _a;
-                    return [
-                        name,
-                        { name, handler: (_a = config.handler) === null || _a === void 0 ? void 0 : _a.toString() },
-                    ];
-                }))
-                : undefined,
-            options: this.options.options,
-            envs: this.options.envs,
-        };
-    }
-}
-// Export singleton instance for convenience
-exports.workflowService = new WorkflowService();
-// Default export
-exports.default = WorkflowService;
-//# sourceMappingURL=workflows.service.js.map