@ductape/sdk 0.0.4-v99 → 0.0.5

package/dist/workflows/workflows.service.js

@@ -106,10 +106,14 @@ class WorkflowService {
         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 === null || config === void 0 ? void 0 : config.env_type, hasRedis: !!(config === null || config === void 0 ? void 0 : 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({
@@ -120,7 +124,14 @@ class WorkflowService {
                     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 ====================
@@ -128,6 +139,7 @@ class WorkflowService {
      * 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);
     }
@@ -136,20 +148,19 @@ class WorkflowService {
      */
     getAuthPayload() {
         if (!this.config) {
+            console.log('[WorkflowService] getAuthPayload failed: no config');
             throw WorkflowError.configurationError('WorkflowService not configured. Please provide config when initializing.');
         }
-        return {
-            user_id: this.config.user_id,
-            workspace_id: this.config.workspace_id,
-            public_key: this.config.public_key,
-            token: this.config.token,
-        };
+        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;
@@ -158,6 +169,8 @@ class WorkflowService {
      * 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 ====================
@@ -166,14 +179,18 @@ class WorkflowService {
      */
     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,
         });
     }
     /**
@@ -182,11 +199,16 @@ class WorkflowService {
     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;
     }
@@ -195,6 +217,7 @@ class WorkflowService {
      */
     initializeLogService() {
         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,
@@ -209,11 +232,25 @@ class WorkflowService {
      * 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 };
     }
     /**
@@ -221,8 +258,10 @@ class WorkflowService {
      */
     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,
@@ -230,6 +269,7 @@ class WorkflowService {
             token: this.config.token,
             env_type: this.config.env_type,
             private_key: this._privateKey,
+            access_key: this.config.access_key,
         });
     }
     // ==================== WORKFLOW CRUD OPERATIONS ====================
@@ -250,13 +290,16 @@ class WorkflowService {
      * ```
      */
     async create(productTag, workflowData) {
-        var _a;
+        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 || !((_a = workflowData.steps) === null || _a === void 0 ? void 0 : _a.length)) {
+        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 = {
@@ -272,6 +315,7 @@ class WorkflowService {
             envs: workflowData.envs,
         };
         this.localConfigs.set(workflowData.tag, localConfig);
+        console.log('[WorkflowService] create SUCCESS', { productTag, tag: workflowData.tag });
     }
     /**
      * Fetch all workflows for a product
@@ -283,19 +327,27 @@ class WorkflowService {
      * ```
      */
     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[]
-            return workflows.map((wf) => this.productWorkflowToConfig(wf));
+            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());
         }
     }
@@ -309,25 +361,33 @@ class WorkflowService {
      * ```
      */
     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;
             }
         }
-        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
@@ -342,6 +402,7 @@ class WorkflowService {
      */
     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);
@@ -351,6 +412,7 @@ class WorkflowService {
             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
@@ -361,11 +423,13 @@ class WorkflowService {
      * ```
      */
     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 ====================
     /**
@@ -397,16 +461,22 @@ class WorkflowService {
      * ```
      */
     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
-        const schema = compiler.compile();
+        // 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
@@ -423,6 +493,7 @@ class WorkflowService {
             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,
@@ -453,41 +524,55 @@ class WorkflowService {
      * ```
      */
     async execute(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        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;
         // Fetch the workflow configuration from backend
         const builder = await this.getProductBuilder(options.product);
+        console.log('[WorkflowService] execute fetching workflow', { tag: options.tag, product: options.product });
         const 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);
+                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);
-        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        (_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,
@@ -501,18 +586,21 @@ class WorkflowService {
                 };
                 const cached = await this.cacheManager.fetch(cacheOptions);
                 if (cached.hit && cached.data) {
-                    (_b = this.logService) === null || _b === void 0 ? void 0 : _b.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 } }));
-                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish();
+                    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
-            const executor = new workflow_executor_1.WorkflowExecutor(this.config, workflow, resolvedOptions, this._privateKey, sessionLogFields);
+            // 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();
-            // Store in cache for idempotency
+            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);
-                await this.cacheManager.store({
+                this.cacheManager.store({
                     cache_tag: cache,
                     product_tag: options.product,
                     component_tag: options.tag,
@@ -523,13 +611,15 @@ class WorkflowService {
                     expiry: cacheConfig.expiry,
                 }, result);
             }
-            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { message: 'Workflow execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
-            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.publish();
+            (_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) {
-            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.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 ((_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish());
+            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;
         }
     }
@@ -560,6 +650,7 @@ class WorkflowService {
      */
     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);
@@ -567,6 +658,7 @@ class WorkflowService {
         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;
@@ -575,12 +667,19 @@ class WorkflowService {
             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);
+                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
@@ -591,6 +690,7 @@ class WorkflowService {
         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,
@@ -604,14 +704,17 @@ class WorkflowService {
                 };
                 const cached = await this.cacheManager.fetch(cacheOptions);
                 if (cached.hit && cached.data) {
-                    (_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 } }));
+                    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}`,
@@ -643,8 +746,10 @@ class WorkflowService {
                     }
                     : 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;
@@ -657,10 +762,10 @@ class WorkflowService {
                 recurring: isRecurring,
                 next_run_at: nextRunAt,
             };
-            // Store in cache for idempotency
+            // Store in cache for idempotency (fire-and-forget)
             if (cache && this.cacheManager && this._privateKey) {
                 const cacheConfig = await this.validateCache(data.product, cache);
-                await this.cacheManager.store({
+                this.cacheManager.store({
                     cache_tag: cache,
                     product_tag: data.product,
                     component_tag: data.workflow,
@@ -673,9 +778,11 @@ class WorkflowService {
             }
             (_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;
@@ -698,6 +805,7 @@ class WorkflowService {
      */
     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) {
@@ -718,16 +826,19 @@ class WorkflowService {
         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;
@@ -749,6 +860,7 @@ class WorkflowService {
      * ```
      */
     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,
@@ -756,10 +868,13 @@ class WorkflowService {
             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 (status.state[options.query] || status);
+        return result;
     }
     // ==================== REPLAY, RESTART & RESUME ====================
     /**
@@ -777,8 +892,10 @@ class WorkflowService {
      */
     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
@@ -796,15 +913,19 @@ class WorkflowService {
         (_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,
@@ -814,9 +935,11 @@ class WorkflowService {
             });
             (_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;
@@ -837,7 +960,9 @@ class WorkflowService {
      * ```
      */
     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
@@ -847,8 +972,10 @@ class WorkflowService {
             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) {
@@ -864,12 +991,14 @@ class WorkflowService {
             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 });
     }
     /**
@@ -886,7 +1015,10 @@ class WorkflowService {
      * ```
      */
     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
@@ -896,15 +1028,19 @@ class WorkflowService {
             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,
@@ -919,6 +1055,7 @@ class WorkflowService {
             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 });
     }
     /**
@@ -935,7 +1072,9 @@ class WorkflowService {
      * ```
      */
     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
@@ -945,20 +1084,24 @@ class WorkflowService {
             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,
@@ -972,6 +1115,7 @@ class WorkflowService {
             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 ====================
@@ -988,12 +1132,15 @@ class WorkflowService {
      * ```
      */
     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,
@@ -1022,9 +1169,22 @@ class WorkflowService {
      * ```
      */
     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,
@@ -1044,9 +1204,12 @@ class WorkflowService {
      * ```
      */
     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,
@@ -1075,12 +1238,15 @@ class WorkflowService {
      * ```
      */
     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,
@@ -1109,9 +1275,12 @@ class WorkflowService {
      * ```
      */
     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) => ({
@@ -1138,9 +1307,11 @@ class WorkflowService {
      * ```
      */
     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,
@@ -1169,21 +1340,198 @@ class WorkflowService {
 }
 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');
+/**
+ * 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;
+}
 /**
- * Recording context that captures step definitions during handler execution
+ * 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);
+        },
+    });
+}
+/**
+ * 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];
+    }
+    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) {
-        this._input = _input;
-        this._workflowTag = _workflowTag;
+    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
+    // Readonly workflow metadata — prefer recordInput for control flow (loops, switch), fall back to $Input{field}
     get input() {
-        return this._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}`;
@@ -1212,39 +1560,86 @@ class RecordingContext {
     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++;
-        // Create step placeholder - will be updated by component calls
+        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,
         };
-        // Execute handler to capture component calls
+        this._pendingStep = step;
+        // Execute handler to capture component calls and step return value
+        let stepReturn;
         try {
-            await handler();
+            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;
         }
-        // Only add if step type was set by a component call
-        if (step.event) {
-            this._steps.push(step);
+        // 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;
-        // Return mock result
-        return {};
+        // 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() {
@@ -1256,7 +1651,6 @@ class RecordingContext {
                     options: { retries: options.retries, timeout: options.timeout },
                 });
                 return {};
-                return {};
             },
         };
     }
@@ -1280,21 +1674,21 @@ class RecordingContext {
             insert: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
                     database: options.database,
-                    input: { data: options.data },
+                    input: { table: options.table, data: options.data },
                 });
                 return {};
             },
             update: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
                     database: options.database,
-                    input: { data: options.data, where: options.where },
+                    input: { table: options.table, data: options.data, where: options.where },
                 });
                 return {};
             },
             delete: async (options) => {
                 this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.DATABASE_ACTION, options.event, {
                     database: options.database,
-                    input: { where: options.where },
+                    input: { table: options.table, where: options.where },
                 });
                 return true;
             },
@@ -1405,10 +1799,25 @@ class RecordingContext {
             },
         };
     }
+    /** 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 },
+                });
+            },
+        };
+    }
+    /** @deprecated Prefer ctx.messaging.produce() */
     get publish() {
         return {
             send: async (options) => {
-                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.PUBLISH, options.event, {
+                this._updateCurrentStep(productsBuilder_types_1.WorkflowStepType.PRODUCE, options.event, {
                     broker: options.broker,
                     input: options.input,
                     options: { retries: options.retries },
@@ -1552,17 +1961,24 @@ class RecordingContext {
     _updateCurrentStep(type, event, data) {
         if (!this._currentStepTag)
             return;
-        // Find or create the step
-        let step = this._steps.find((s) => s.tag === this._currentStepTag);
+        // 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) {
-            step = {
+            const newStep = {
                 tag: this._currentStepTag,
                 type,
                 event,
                 input: data.input || {},
             };
-            this._steps.push(step);
+            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;
@@ -1584,18 +2000,20 @@ class RecordingContext {
             step.fallback = data.fallback;
         if (data.workflow)
             step.workflow = data.workflow;
-        if (data.input)
-            step.input = data.input;
+        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);
         this._steps.push({
             tag,
             type,
             event,
-            input: data,
+            input,
         });
     }
     _parseDuration(duration) {
@@ -1619,6 +2037,16 @@ class RecordingContext {
                 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;
@@ -1637,9 +2065,9 @@ class WorkflowCompiler {
      * Executes the handler with a recording context to capture step definitions
      */
     compile() {
-        // Create recording context with mock input
-        const mockInput = {};
-        const recordingCtx = new RecordingContext(mockInput, this.options.tag);
+        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
@@ -1659,8 +2087,8 @@ class WorkflowCompiler {
             name: this.options.name,
             tag: this.options.tag,
             description: this.options.description,
-            input: {},
-            output: {},
+            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 }]))
@@ -1680,26 +2108,62 @@ class WorkflowCompiler {
     }
     /**
      * Compile the workflow definition asynchronously
-     * Fully awaits the handler to capture all step definitions
+     * 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() {
-        // Create recording context with mock input
-        const mockInput = {};
-        const recordingCtx = new RecordingContext(mockInput, this.options.tag);
-        // Execute handler to trace step definitions
-        try {
-            await this.options.handler(recordingCtx);
-        }
-        catch (e) {
-            // Ignore errors during compilation - we're tracing structure, not executing
+        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: {},
-            output: {},
-            steps: recordingCtx.getSteps(),
+            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,