@ductape/sdk 0.1.25 → 0.1.27

package/dist/features/features.service.js

@@ -0,0 +1,2222 @@
+"use strict";
+/**
+ * Feature Service
+ *
+ * Main service class for feature operations.
+ * Provides CRUD operations and execution for Ductape Features.
+ *
+ * Based on Ductape Features 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.featureService = exports.FeatureService = exports.FeatureError = 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 featureApi_service_1 = require("../api/services/featureApi.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 feature_executor_1 = require("./feature-executor");
+/**
+ * Error class for feature-related errors
+ */
+class FeatureError 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 = 'FeatureError';
+    }
+    static configurationError(message) {
+        return new FeatureError(message, 'CONFIGURATION_ERROR');
+    }
+    static validationError(message, details) {
+        return new FeatureError(message, 'VALIDATION_ERROR', details);
+    }
+    static notFoundError(message) {
+        return new FeatureError(message, 'NOT_FOUND');
+    }
+    static executionError(message, details) {
+        return new FeatureError(message, 'EXECUTION_ERROR', details);
+    }
+}
+exports.FeatureError = FeatureError;
+/**
+ * Main Feature Service class
+ * Provides unified interface for feature management and execution
+ */
+class FeatureService {
+    /**
+     * Create a new FeatureService 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 feature configurations */
+        this.localConfigs = new Map();
+        /** Feature API service for backend communication */
+        this.featureApiService = 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('[FeatureService] 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.featureApiService = new featureApi_service_1.FeatureApiService(config.env_type);
+            console.log('[FeatureService] FeatureApiService 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('[FeatureService] CacheManager initialized');
+            }
+            else {
+                console.log('[FeatureService] No redis_client provided, cache disabled');
+            }
+        }
+        else {
+            //console.log('[FeatureService] No config provided, service unconfigured');
+        }
+    }
+    // ==================== CONFIGURATION ====================
+    /**
+     * Update service configuration
+     */
+    updateConfig(config) {
+        console.log('[FeatureService] updateConfig', { env_type: config.env_type, workspace_id: config.workspace_id });
+        this.config = config;
+        this.featureApiService = new featureApi_service_1.FeatureApiService(config.env_type);
+    }
+    /**
+     * Get auth payload for API calls
+     */
+    getAuthPayload() {
+        if (!this.config) {
+            console.log('[FeatureService] getAuthPayload failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        const hasAccessKey = !!this.config.access_key;
+        console.log('[FeatureService] 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 FeatureApiService is initialized
+     */
+    ensureApiService() {
+        if (!this.featureApiService) {
+            console.log('[FeatureService] ensureApiService failed: FeatureApiService not initialized');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        return this.featureApiService;
+    }
+    /**
+     * Get service configuration
+     */
+    getConfig() {
+        var _a;
+        console.log('[FeatureService] 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('[FeatureService] createNewProductBuilder failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        console.log('[FeatureService] 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('[FeatureService] 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('[FeatureService] getProductBuilder initialized', { productTag, productId: this.productId });
+        }
+        else {
+            console.log('[FeatureService] getProductBuilder cache hit', { productTag });
+        }
+        return builder;
+    }
+    /**
+     * Initialize logging service
+     */
+    initializeLogService() {
+        var _a;
+        if (!this.logService && this.config) {
+            console.log('[FeatureService] 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('[FeatureService] validateCache', { productTag, cacheTag, cacheKey, hasCached: !!cached });
+        // Return cached config if still valid
+        if (cached && (now - cached.fetchedAt) < CACHE_TTL) {
+            console.log('[FeatureService] 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('[FeatureService] validateCache cache config not found', { cacheTag });
+            throw FeatureError.validationError(`Cache configuration '${cacheTag}' does not exist`);
+        }
+        this.cacheConfigCache.set(cacheKey, { expiry: cache.expiry, fetchedAt: now });
+        console.log('[FeatureService] 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('[FeatureService] createNewProcessor failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        console.log('[FeatureService] 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 feature from JSON schema
+     *
+     * @example
+     * ```ts
+     * await ductape.feature.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, featureData) {
+        var _a, _b, _c;
+        console.log('[FeatureService] create ENTRY', { productTag, tag: featureData.tag, name: featureData.name, stepsCount: (_b = (_a = featureData.steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
+        // Validate required fields
+        if (!featureData.name || !featureData.tag || !((_c = featureData.steps) === null || _c === void 0 ? void 0 : _c.length)) {
+            console.log('[FeatureService] create validation failed: missing name, tag, or steps');
+            throw FeatureError.validationError('Feature requires name, tag, and at least one step');
+        }
+        // Persist to backend using ProductBuilder
+        const builder = await this.getProductBuilder(productTag);
+        console.log('[FeatureService] create calling builder.createFeature', { tag: featureData.tag });
+        await builder.createFeature(featureData);
+        // Store locally
+        const localConfig = {
+            name: featureData.name,
+            tag: featureData.tag,
+            description: featureData.description,
+            input: featureData.input,
+            output: featureData.output,
+            steps: featureData.steps,
+            signals: featureData.signals,
+            queries: featureData.queries,
+            options: featureData.options,
+            envs: featureData.envs,
+        };
+        this.localConfigs.set(featureData.tag, localConfig);
+        console.log('[FeatureService] create SUCCESS', { productTag, tag: featureData.tag });
+    }
+    /**
+     * Fetch all features for a product
+     *
+     * @example
+     * ```ts
+     * const features = await ductape.feature.fetchAll('my-product');
+     * features.forEach(f => console.log(f.name, f.tag));
+     * ```
+     */
+    async fetchAll(productTag) {
+        var _a;
+        console.log('[FeatureService] fetchAll ENTRY', { productTag });
+        // Return local configs if no product tag
+        if (!productTag) {
+            const localCount = this.localConfigs.size;
+            console.log('[FeatureService] 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('[FeatureService] fetchAll calling builder.fetchWorkflows', { productTag });
+            const features = await builder.fetchFeatures();
+            // Convert IProductFeature[] to IFeatureConfig[]
+            const result = features.map((f) => this.productFeatureToConfig(f));
+            console.log('[FeatureService] fetchAll SUCCESS', { productTag, count: result.length });
+            return result;
+        }
+        catch (error) {
+            // Fall back to local configs if API fails
+            console.log('[FeatureService] 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 feature by tag
+     *
+     * @example
+     * ```ts
+     * const feature = await ductape.feature.fetch('order-fulfillment', 'my-product');
+     * console.log(feature?.name, feature?.steps.length);
+     * ```
+     */
+    async fetch(featureTag, productTag) {
+        var _a, _b;
+        console.log('[FeatureService] fetch ENTRY', { featureTag, productTag });
+        // If productTag is provided, fetch from API
+        if (productTag) {
+            try {
+                const builder = await this.getProductBuilder(productTag);
+                console.log('[FeatureService] fetch calling builder.fetchWorkflow', { featureTag, productTag });
+                const feature = await builder.fetchFeature(featureTag);
+                if (feature) {
+                    const config = this.productFeatureToConfig(feature);
+                    // Update local cache
+                    this.localConfigs.set(featureTag, config);
+                    console.log('[FeatureService] fetch SUCCESS from API', { featureTag, productTag, stepsCount: (_a = config.steps) === null || _a === void 0 ? void 0 : _a.length });
+                    return config;
+                }
+                console.log('[FeatureService] fetch not found on API', { featureTag, productTag });
+                return null;
+            }
+            catch (error) {
+                // Fall back to local config
+                console.log('[FeatureService] fetch API failed, trying local', { featureTag, productTag, error: (_b = error === null || error === void 0 ? void 0 : error.message) !== null && _b !== void 0 ? _b : error });
+                return this.localConfigs.get(featureTag) || null;
+            }
+        }
+        const local = this.localConfigs.get(featureTag) || null;
+        console.log('[FeatureService] fetch from local only', { featureTag, found: !!local });
+        return local;
+    }
+    /**
+     * Update a feature
+     *
+     * @example
+     * ```ts
+     * await ductape.feature.update('order-fulfillment', 'my-product', {
+     *   description: 'Updated description',
+     *   options: { timeout: 3600000 },
+     * });
+     * ```
+     */
+    async update(featureTag, productTag, updates) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        console.log('[FeatureService] update ENTRY', { featureTag, productTag, updateKeys: Object.keys(updates || {}) });
+        // Update in backend
+        const builder = await this.getProductBuilder(productTag);
+        await builder.updateFeature(featureTag, updates);
+        // Update local cache
+        const existing = this.localConfigs.get(featureTag);
+        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(featureTag, updated);
+        }
+        console.log('[FeatureService] update SUCCESS', { featureTag, productTag });
+    }
+    /**
+     * Delete a feature
+     *
+     * @example
+     * ```ts
+     * await ductape.feature.delete('order-fulfillment', 'my-product');
+     * ```
+     */
+    async delete(featureTag, productTag) {
+        console.log('[FeatureService] delete ENTRY', { featureTag, productTag });
+        // Delete from backend
+        const builder = await this.getProductBuilder(productTag);
+        await builder.deleteFeature(featureTag);
+        // Remove from local cache
+        this.localConfigs.delete(featureTag);
+        console.log('[FeatureService] delete SUCCESS', { featureTag, productTag });
+    }
+    // ==================== CODE-FIRST API ====================
+    /**
+     * Define a feature using the code-first API
+     * Compiles the handler to JSON schema and creates the feature in one step
+     *
+     * @example
+     * ```ts
+     * const orderFeature = await ductape.feature.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('[FeatureService] define ENTRY', { tag: options.tag, name: options.name, product: options.product });
+        // Validate required fields
+        if (!options.tag || !options.name || !options.handler) {
+            console.log('[FeatureService] define validation failed: missing tag, name, or handler');
+            throw FeatureError.validationError('Feature definition requires tag, name, and handler');
+        }
+        // Create a feature compiler instance
+        const compiler = new FeatureCompiler(options);
+        // Compile the handler to JSON schema (await so async handler runs and steps are captured)
+        console.log('[FeatureService] define compiling handler (compileAsync)', { tag: options.tag });
+        const schema = await compiler.compileAsync();
+        console.log('[FeatureService] 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 feature
+        if (options.product) {
+            console.log('[FeatureService] define creating feature 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('[FeatureService] define SUCCESS', { tag: options.tag, product: options.product });
+        // Return the defined feature with compile method
+        return {
+            tag: options.tag,
+            name: options.name,
+            handler: options.handler,
+            compile: () => schema,
+            schema,
+        };
+    }
+    // ==================== WORKFLOW EXECUTION ====================
+    /**
+     * Execute a feature
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.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('[FeatureService] execute ENTRY', { product: options.product, env: options.env, tag: options.tag, hasSession: !!options.session, cache: options.cache });
+        if (!this.config) {
+            console.log('[FeatureService] execute failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        console.log('[FeatureService] execute process_id', { process_id });
+        // Session log fields (will be populated if session is provided)
+        let sessionLogFields = {};
+        let resolvedOptions = options;
+        // Prefer locally cached feature (from a recent define()) so step conditions and full schema are preserved
+        const builder = await this.getProductBuilder(options.product);
+        console.log('[FeatureService] execute fetching feature', { tag: options.tag, product: options.product });
+        const localConfig = this.localConfigs.get(options.tag);
+        let feature = localConfig
+            ? Object.assign(Object.assign({}, localConfig), { tag: localConfig.tag, name: localConfig.name, steps: localConfig.steps }) : null;
+        if (feature) {
+            console.log('[FeatureService] execute using local feature config', { tag: options.tag });
+        }
+        if (!feature) {
+            feature = await builder.fetchFeature(options.tag);
+        }
+        if (!feature) {
+            console.log('[FeatureService] execute feature not found', { tag: options.tag });
+            throw FeatureError.notFoundError(`Feature ${options.tag} not found`);
+        }
+        console.log('[FeatureService] execute feature loaded', { tag: feature.tag, stepsCount: (_b = (_a = feature.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('[FeatureService] execute session validation failed', { error: sessionResult.error });
+                    throw FeatureError.executionError(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedOptions = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+                console.log('[FeatureService] 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.FEATURE, parent_tag: options.tag, data: { feature: options.tag, operation: 'execute' } }, sessionLogFields);
+        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature 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('[FeatureService] 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: 'feature',
+                    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('[FeatureService] execute cache HIT', { cache, source: cached.source });
+                    (_d = this.logService) === null || _d === void 0 ? void 0 : _d.add(Object.assign(Object.assign({}, baseLogs), { message: `Feature execute - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { feature: 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 feature executor with resolved options and session context (pass builder to avoid duplicate init)
+            console.log('[FeatureService] execute creating FeatureExecutor and running', { tag: options.tag });
+            const executor = new feature_executor_1.FeatureExecutor(this.config, feature, resolvedOptions, this._privateKey, sessionLogFields, builder);
+            const result = await executor.execute();
+            console.log('[FeatureService] 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: 'feature',
+                    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: 'Feature execute - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.publish();
+            console.log('[FeatureService] execute SUCCESS', { tag: options.tag, process_id });
+            return result;
+        }
+        catch (error) {
+            console.log('[FeatureService] 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: 'Feature execute - failed', failed_execution: true, data: { feature: 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 feature to run as a scheduled job
+     *
+     * @example
+     * ```ts
+     * // Schedule a feature to run in 1 hour
+     * const result = await ductape.feature.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature: 'order-fulfillment',
+     *   input: { order_id: 'ORD-123' },
+     *   schedule: { start_at: Date.now() + 3600000 },
+     * });
+     *
+     * // Run on a cron schedule
+     * const result = await ductape.feature.dispatch({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature: 'daily-report',
+     *   input: {},
+     *   schedule: { cron: '0 0 * * *' }, // Daily at midnight
+     * });
+     * ```
+     */
+    async dispatch(data) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        console.log('[FeatureService] dispatch ENTRY', { product: data.product, env: data.env, feature: data.feature, 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 feature
+        const jobTag = `feature:${data.feature}`;
+        console.log('[FeatureService] 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('[FeatureService] dispatch session validation failed', { error: sessionResult.error });
+                    throw FeatureError.executionError(`Session validation failed: ${sessionResult.error}`);
+                }
+                resolvedData = sessionResult.input;
+                sessionLogFields = sessionResult.logFields;
+                console.log('[FeatureService] 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.FEATURE, parent_tag: data.feature, data: { feature: data.feature, operation: 'dispatch' } }, sessionLogFields);
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature 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('[FeatureService] dispatch checking cache', { cache, feature: data.feature });
+                const cacheConfig = await this.validateCache(data.product, cache);
+                const cacheOptions = {
+                    cache_tag: cache,
+                    product_tag: data.product,
+                    component_tag: data.feature,
+                    component_type: 'feature',
+                    operation: 'dispatch',
+                    input: { feature: data.feature, 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('[FeatureService] dispatch cache HIT', { cache, source: cached.source });
+                    (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: `Feature dispatch - cache hit (${cached.source})`, successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS, data: { feature: data.feature, 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('[FeatureService] dispatch fetching existing job', { jobTag });
+            const existingJob = await productBuilder.fetchJob(jobTag);
+            if (!existingJob) {
+                console.log('[FeatureService] dispatch job not found, creating', { jobTag });
+                await productBuilder.createJob({
+                    tag: jobTag,
+                    name: `Feature: ${data.feature}`,
+                    description: `Auto-created job for feature ${data.feature}`,
+                    type: productsBuilder_types_1.JobEventTypes.FEATURE, // Use feature (formerly feature) job type
+                    app: data.feature,
+                    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('[FeatureService] dispatch calling processJob', { jobTag, hasRepeat: !!(schedule.cron || schedule.every) });
+            await processorService.processJob(jobInput);
+            const isRecurring = !!(schedule.cron || schedule.every);
+            console.log('[FeatureService] 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.feature,
+                    component_type: 'feature',
+                    operation: 'dispatch',
+                    input: { feature: data.feature, 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: 'Feature dispatch - success', successful_execution: true, data: { feature: data.feature, operation: 'dispatch', job_id }, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_f = this.logService) === null || _f === void 0 ? void 0 : _f.publish();
+            console.log('[FeatureService] dispatch SUCCESS', { feature: data.feature, job_id: result.job_id, status: result.status });
+            return result;
+        }
+        catch (error) {
+            console.log('[FeatureService] dispatch FAILED', { feature: data.feature, error: String(error) });
+            (_g = this.logService) === null || _g === void 0 ? void 0 : _g.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature dispatch - failed', failed_execution: true, data: { feature: data.feature, 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 feature
+     *
+     * @example
+     * ```ts
+     * await ductape.feature.signal({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   signal: 'approve',
+     *   payload: { approver_id: 'user-456', comments: 'Approved' },
+     * });
+     * ```
+     */
+    async signal(options) {
+        var _a, _b, _c, _d, _e, _f;
+        console.log('[FeatureService] signal ENTRY', { feature_id: options.feature_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.FEATURE,
+            parent_tag: options.feature_id,
+            child_tag: options.signal,
+            data: { feature_id: options.feature_id, signal: options.signal, operation: 'signal' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature signal - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            const apiService = this.ensureApiService();
+            const auth = this.getAuthPayload();
+            console.log('[FeatureService] signal calling apiService.sendSignal', { feature_id: options.feature_id, signal: options.signal });
+            await apiService.sendSignal(options.feature_id, {
+                product: options.product,
+                env: options.env,
+                signal: options.signal,
+                payload: options.payload,
+            }, auth);
+            console.log('[FeatureService] signal SUCCESS', { feature_id: options.feature_id, signal: options.signal });
+            (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature 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('[FeatureService] signal FAILED', { feature_id: options.feature_id, signal: options.signal, error: String(error) });
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature signal - failed', failed_execution: true, data: { feature_id: options.feature_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 feature
+     *
+     * @example
+     * ```ts
+     * const status = await ductape.feature.query({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   query: 'getStatus',
+     * });
+     *
+     * console.log(status.current_step, status.progress);
+     * ```
+     */
+    async query(options) {
+        console.log('[FeatureService] query ENTRY', { feature_id: options.feature_id, query: options.query, product: options.product, env: options.env });
+        // Query is handled by getting feature status and extracting query result
+        const status = await this.status({
+            product: options.product,
+            env: options.env,
+            feature_id: options.feature_id,
+        });
+        if (!status) {
+            console.log('[FeatureService] query feature not found', { feature_id: options.feature_id });
+            throw FeatureError.notFoundError(`Feature ${options.feature_id} not found`);
+        }
+        const result = (status.state[options.query] || status);
+        console.log('[FeatureService] query SUCCESS', { feature_id: options.feature_id, query: options.query, hasResult: result !== undefined });
+        // Return the state which contains query results
+        return result;
+    }
+    // ==================== REPLAY, RESTART & RESUME ====================
+    /**
+     * Replay a feature with the same input
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.replay({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   reason: 'Debugging payment failure',
+     * });
+     * ```
+     */
+    async replay(options) {
+        var _a, _b, _c, _d, _e, _f;
+        console.log('[FeatureService] replay ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env });
+        const process_id = (0, processor_utils_1.generateObjectId)();
+        if (!this.config) {
+            console.log('[FeatureService] replay failed: no config');
+            throw FeatureError.configurationError('FeatureService 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.FEATURE,
+            parent_tag: options.feature_id,
+            data: { feature_id: options.feature_id, operation: 'replay' },
+        };
+        (_b = this.logService) === null || _b === void 0 ? void 0 : _b.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature replay - initiated', status: logs_types_1.LogEventStatus.PROCESSING }));
+        try {
+            // Get original feature execution state from backend
+            console.log('[FeatureService] replay fetching original status', { feature_id: options.feature_id });
+            const originalStatus = await this.status({
+                product: options.product,
+                env: options.env,
+                feature_id: options.feature_id,
+            });
+            if (!originalStatus) {
+                console.log('[FeatureService] replay original feature not found', { feature_id: options.feature_id });
+                throw FeatureError.notFoundError(`Feature ${options.feature_id} not found`);
+            }
+            console.log('[FeatureService] replay original status', { workflow_tag: originalStatus.feature_tag, status: originalStatus.status });
+            // Execute with the same input
+            console.log('[FeatureService] replay executing with same input', { tag: originalStatus.feature_tag });
+            const result = await this.execute({
+                product: options.product,
+                env: options.env,
+                tag: originalStatus.feature_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: 'Feature replay - success', successful_execution: true, status: logs_types_1.LogEventStatus.SUCCESS }));
+            (_d = this.logService) === null || _d === void 0 ? void 0 : _d.publish();
+            console.log('[FeatureService] replay SUCCESS', { feature_id: options.feature_id, replayed_from: options.feature_id });
+            return Object.assign(Object.assign({}, result), { replayed_from: options.feature_id });
+        }
+        catch (error) {
+            console.log('[FeatureService] replay FAILED', { feature_id: options.feature_id, error: String(error) });
+            (_e = this.logService) === null || _e === void 0 ? void 0 : _e.add(Object.assign(Object.assign({}, baseLogs), { message: 'Feature replay - failed', failed_execution: true, data: { feature_id: options.feature_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 feature with new or modified input
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.restart({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   input: { email: 'corrected@email.com' },
+     *   reason: 'Customer email was incorrect',
+     * });
+     * ```
+     */
+    async restart(options) {
+        console.log('[FeatureService] restart ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env, hasInput: !!options.input });
+        if (!this.config) {
+            console.log('[FeatureService] restart failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        // Get original feature execution state from backend
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            feature_id: options.feature_id,
+        });
+        if (!originalStatus) {
+            console.log('[FeatureService] restart feature not found', { feature_id: options.feature_id });
+            throw FeatureError.notFoundError(`Feature ${options.feature_id} not found`);
+        }
+        console.log('[FeatureService] restart original status', { workflow_tag: originalStatus.feature_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('[FeatureService] restart executing with new input', { tag: originalStatus.feature_tag, inputKeys: Object.keys(newInput || {}) });
+        const result = await this.execute({
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.feature_tag,
+            input: newInput,
+        });
+        console.log('[FeatureService] restart SUCCESS', { feature_id: options.feature_id, restarted_from: options.feature_id });
+        return Object.assign(Object.assign({}, result), { restarted_from: options.feature_id });
+    }
+    /**
+     * Resume a paused or failed feature from where it stopped
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.resume({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   from_checkpoint: 'payment-complete',
+     * });
+     * ```
+     */
+    async resume(options) {
+        var _a, _b;
+        console.log('[FeatureService] resume ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env, from_checkpoint: options.from_checkpoint, from_step: options.from_step });
+        if (!this.config) {
+            console.log('[FeatureService] resume failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        // Get original feature execution state from backend
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            feature_id: options.feature_id,
+        });
+        if (!originalStatus) {
+            console.log('[FeatureService] resume feature not found', { feature_id: options.feature_id });
+            throw FeatureError.notFoundError(`Feature ${options.feature_id} not found`);
+        }
+        console.log('[FeatureService] resume original status', { workflow_tag: originalStatus.feature_tag, completed_steps: (_b = (_a = originalStatus.completed_steps) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 });
+        // Fetch the feature configuration
+        const builder = await this.getProductBuilder(options.product);
+        const feature = await builder.fetchFeature(originalStatus.feature_tag);
+        if (!feature) {
+            console.log('[FeatureService] resume feature config not found', { tag: originalStatus.feature_tag });
+            throw FeatureError.notFoundError(`Feature  not found`);
+        }
+        // Create executor with resume options
+        console.log('[FeatureService] resume creating executor and resuming', { tag: feature.tag });
+        const executor = new feature_executor_1.FeatureExecutor(this.config, feature, {
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.feature_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('[FeatureService] resume SUCCESS', { feature_id: options.feature_id, resumed_from: options.feature_id });
+        return Object.assign(Object.assign({}, result), { resumed_from: options.feature_id, resumed_checkpoint: options.from_checkpoint });
+    }
+    /**
+     * Replay a feature starting from a specific step
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.replayFromStep({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   from_step: 'process-payment',
+     * });
+     * ```
+     */
+    async replayFromStep(options) {
+        console.log('[FeatureService] replayFromStep ENTRY', { feature_id: options.feature_id, from_step: options.from_step, product: options.product, env: options.env });
+        if (!this.config) {
+            console.log('[FeatureService] replayFromStep failed: no config');
+            throw FeatureError.configurationError('FeatureService not configured. Please provide config when initializing.');
+        }
+        // Get original feature execution state
+        const originalStatus = await this.status({
+            product: options.product,
+            env: options.env,
+            feature_id: options.feature_id,
+        });
+        if (!originalStatus) {
+            console.log('[FeatureService] replayFromStep feature not found', { feature_id: options.feature_id });
+            throw FeatureError.notFoundError(`Feature ${options.feature_id} not found`);
+        }
+        // Fetch the feature configuration
+        const builder = await this.getProductBuilder(options.product);
+        const feature = await builder.fetchFeature(originalStatus.feature_tag);
+        if (!feature) {
+            console.log('[FeatureService] replayFromStep feature config not found', { tag: originalStatus.feature_tag });
+            throw FeatureError.notFoundError(`Feature  not found`);
+        }
+        // Find steps before from_step to mark as completed
+        const stepIndex = feature.steps.findIndex((s) => s.tag === options.from_step);
+        if (stepIndex === -1) {
+            console.log('[FeatureService] replayFromStep step not found', { from_step: options.from_step });
+            throw FeatureError.validationError(`Step ${options.from_step} not found in feature`);
+        }
+        const completedSteps = feature.steps.slice(0, stepIndex).map((s) => s.tag);
+        console.log('[FeatureService] replayFromStep stepIndex and completedSteps', { from_step: options.from_step, stepIndex, completedStepsCount: completedSteps.length });
+        // Create executor with partial state
+        const executor = new feature_executor_1.FeatureExecutor(this.config, feature, {
+            product: options.product,
+            env: options.env,
+            tag: originalStatus.feature_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('[FeatureService] replayFromStep SUCCESS', { feature_id: options.feature_id, from_step: options.from_step });
+        return Object.assign(Object.assign({}, result), { replayed_from: options.feature_id });
+    }
+    // ==================== STATUS & MANAGEMENT ====================
+    /**
+     * Get the status of a feature execution
+     *
+     * @example
+     * ```ts
+     * const status = await ductape.feature.status({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     * });
+     * ```
+     */
+    async status(options) {
+        console.log('[FeatureService] status ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env });
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getStatus(options.feature_id, options.product, options.env, auth);
+        if (!response) {
+            console.log('[FeatureService] status not found', { feature_id: options.feature_id });
+            return null;
+        }
+        console.log('[FeatureService] status SUCCESS', { feature_id: response.feature_id, feature_tag: response.feature_tag, status: response.status });
+        return {
+            feature_id: response.feature_id,
+            feature_tag: response.feature_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 feature
+     *
+     * @example
+     * ```ts
+     * const result = await ductape.feature.cancel({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   reason: 'User requested cancellation',
+     * });
+     * ```
+     */
+    async cancel(options) {
+        var _a, _b, _c, _d;
+        console.log('[FeatureService] cancel ENTRY', {
+            feature_id: options.feature_id,
+            product: options.product,
+            env: options.env,
+            reason: options.reason,
+        });
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.cancel(options.feature_id, options.product, options.env, options.reason || 'Cancelled by user', auth);
+        console.log('[FeatureService] cancel SUCCESS', {
+            feature_id: options.feature_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 feature
+     *
+     * @example
+     * ```ts
+     * const history = await ductape.feature.history({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     * });
+     * ```
+     */
+    async history(options) {
+        var _a, _b, _c, _d;
+        console.log('[FeatureService] history ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env });
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getHistory(options.feature_id, options.product, options.env, auth);
+        console.log('[FeatureService] history SUCCESS', { feature_id: response.feature_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 {
+            feature_id: response.feature_id,
+            feature_tag: response.feature_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.feature.stepDetail({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     *   step_tag: 'process-payment',
+     * });
+     * ```
+     */
+    async stepDetail(options) {
+        console.log('[FeatureService] stepDetail ENTRY', { feature_id: options.feature_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.feature_id, options.step_tag, options.product, options.env, auth);
+        if (!response) {
+            console.log('[FeatureService] stepDetail not found', { feature_id: options.feature_id, step_tag: options.step_tag });
+            return null;
+        }
+        console.log('[FeatureService] stepDetail SUCCESS', { feature_id: options.feature_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.feature.relatedExecutions({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_id: 'wf-123',
+     * });
+     * ```
+     */
+    async relatedExecutions(options) {
+        var _a, _b;
+        console.log('[FeatureService] relatedExecutions ENTRY', { feature_id: options.feature_id, product: options.product, env: options.env });
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.getRelatedExecutions(options.feature_id, options.product, options.env, auth);
+        console.log('[FeatureService] relatedExecutions SUCCESS', { feature_id: options.feature_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) => ({
+                feature_id: e.feature_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 feature executions
+     *
+     * @example
+     * ```ts
+     * const comparison = await ductape.feature.compare({
+     *   product: 'my-product',
+     *   env: 'production',
+     *   feature_ids: ['wf-123', 'wf-456'],
+     * });
+     * ```
+     */
+    async compare(options) {
+        console.log('[FeatureService] compare ENTRY', { feature_ids: options.feature_ids, product: options.product, env: options.env });
+        const apiService = this.ensureApiService();
+        const auth = this.getAuthPayload();
+        const response = await apiService.compareExecutions(options.feature_ids, options.product, options.env, auth);
+        console.log('[FeatureService] compare SUCCESS', { feature_ids: response.features });
+        return {
+            features: response.features,
+            input_diff: response.input_diff,
+            step_diffs: response.step_diffs,
+            outcome_diff: response.outcome_diff,
+        };
+    }
+    // ==================== HELPER METHODS ====================
+    /**
+     * Convert IProductFeature to IFeatureConfig
+     */
+    productFeatureToConfig(feature) {
+        return {
+            name: feature.name,
+            tag: feature.tag,
+            description: feature.description,
+            input: feature.input,
+            output: feature.output,
+            steps: feature.steps,
+            signals: feature.signals,
+            queries: feature.queries,
+            options: feature.options,
+            envs: feature.envs,
+        };
+    }
+}
+exports.FeatureService = FeatureService;
+// ==================== WORKFLOW COMPILER ====================
+/** Symbol to detect feature 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 feature 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(featureTag, 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(featureTag, 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 feature 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 feature 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, featureTag, featureInputSchema, 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._featureTag = featureTag;
+        this._inputSchemaKeys = featureInputSchema ? Object.keys(featureInputSchema) : [];
+        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 feature 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 feature_id() {
+        return `compile-${this._featureTag}`;
+    }
+    get feature_tag() {
+        return this._featureTag;
+    }
+    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.FeatureStepType.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._featureTag, step.tag, '', recordUsage);
+    }
+    // ==================== COMPONENT CONTEXTS ====================
+    get action() {
+        return {
+            run: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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.FeatureStepType.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.FeatureStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: options.params || {},
+                });
+                return createStepOutputProxy();
+            },
+            insert: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.DATABASE_ACTION, options.event, {
+                    database: options.database,
+                    input: { table: options.table, data: options.data },
+                });
+                return createStepOutputProxy();
+            },
+            update: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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.FeatureStepType.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.FeatureStepType.GRAPH, options.action, {
+                    graph: options.graph,
+                    input: options.input,
+                });
+                return createStepOutputProxy();
+            },
+            createNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.GRAPH, 'createNode', {
+                    graph: options.graph,
+                    input: { labels: options.labels, properties: options.properties },
+                });
+                return createStepOutputProxy();
+            },
+            updateNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.GRAPH, 'updateNode', {
+                    graph: options.graph,
+                    input: { id: options.id, properties: options.properties },
+                });
+                return createStepOutputProxy();
+            },
+            deleteNode: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.GRAPH, 'deleteNode', {
+                    graph: options.graph,
+                    input: { id: options.id },
+                });
+                return createStepOutputProxy();
+            },
+            createRelationship: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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.FeatureStepType.GRAPH, 'deleteRelationship', {
+                    graph: options.graph,
+                    input: { id: options.id },
+                });
+                return createStepOutputProxy();
+            },
+            query: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.GRAPH, options.action, {
+                    graph: options.graph,
+                    input: options.params || {},
+                });
+                return createStepOutputProxy();
+            },
+        };
+    }
+    get notification() {
+        return {
+            send: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.NOTIFICATION, options.event, {
+                    notification: options.notification,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+                return createStepOutputProxy();
+            },
+            email: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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.FeatureStepType.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.FeatureStepType.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.FeatureStepType.STORAGE, options.event, {
+                    storage: options.storage,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+                return createStepOutputProxy();
+            },
+            download: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.STORAGE, options.event, {
+                    storage: options.storage,
+                    input: options.input,
+                });
+                return createStepOutputProxy();
+            },
+            delete: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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 events() {
+        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.FeatureStepType.PRODUCE, topic, {
+                    broker,
+                    input: { message: options.message },
+                });
+                return createStepOutputProxy();
+            },
+        };
+    }
+    /** @deprecated Prefer ctx.events.produce() */
+    get publish() {
+        return {
+            send: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.PRODUCE, options.event, {
+                    broker: options.broker,
+                    input: options.input,
+                    options: { retries: options.retries },
+                });
+                return createStepOutputProxy();
+            },
+        };
+    }
+    get quota() {
+        return {
+            execute: async (options) => {
+                this._updateCurrentStep(productsBuilder_types_1.FeatureStepType.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.FeatureStepType.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.FeatureStepType.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.FeatureStepType.WAIT_FOR_SIGNAL, signals[0], {
+            signals,
+            options: timeout ? { timeout } : undefined,
+        });
+        return {};
+    }
+    async checkpoint(name, metadata) {
+        this._addControlStep(productsBuilder_types_1.FeatureStepType.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 feature(childId, tag, input, options) {
+        this._addControlStep(productsBuilder_types_1.FeatureStepType.CHILD_FEATURE, 'execute', {
+            feature: 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.feature)
+            step.feature = data.feature;
+        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.feature != null)
+            step.feature = data.feature;
+        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 feature 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 feature definitions to JSON schema
+ * Uses runtime handler tracing to capture step definitions
+ */
+class FeatureCompiler {
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Compile the feature 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 feature 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.featureService = new FeatureService();
+// Default export
+exports.default = FeatureService;
+//# sourceMappingURL=features.service.js.map