@orbytautomation/engine 0.1.0

package/dist/execution/ExecutionPlan.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Execution Plan
+ *
+ * PURE COORDINATION - NO EXECUTION LOGIC.
+ *
+ * This coordinates DependencyResolver, CycleDetector, and TopologicalSorter
+ * to create a valid execution plan. It answers:
+ * - What runs?
+ * - In what order?
+ * - What can run in parallel?
+ * - What are the constraints?
+ *
+ * This is "designing the map, not driving the car."
+ * Execution happens elsewhere (StepExecutor, WorkflowExecutor).
+ *
+ * @module execution
+ */
+import { ExecutionNode } from './ExecutionNode.js';
+import { type DependencyGraph, type TopologicalSortResult } from '../graph/DependencyGraph.js';
+/**
+ * Execution phase (group of steps that can run in parallel)
+ */
+export interface ExecutionPhase {
+    /** Phase number (0-indexed) */
+    readonly phase: number;
+    /** Nodes that can execute in parallel */
+    readonly nodes: readonly ExecutionNode[];
+    /** Combined phase timeout (max of all node timeouts) */
+    readonly timeout?: number;
+}
+/**
+ * Complete execution plan for a workflow.
+ * This is a blueprint for execution - it contains NO execution state.
+ */
+export interface ExecutionPlan {
+    /** Ordered phases of execution */
+    readonly phases: readonly ExecutionPhase[];
+    /** The validated dependency graph */
+    readonly graph: DependencyGraph;
+    /** Total number of steps */
+    readonly totalSteps: number;
+    /** Maximum parallelism (largest phase size) */
+    readonly maxParallelism: number;
+    /** Critical path length (minimum phases needed) */
+    readonly criticalPathLength: number;
+    /** Topological sort result */
+    readonly sortResult: TopologicalSortResult;
+}
+/**
+ * Execution plan coordinator.
+ * This orchestrates graph utilities to create execution plans.
+ *
+ * NO EXECUTION LOGIC HERE - only planning and coordination.
+ */
+export declare class ExecutionPlanner {
+    /**
+     * Create execution plan from execution nodes.
+     *
+     * This is the main entry point. It:
+     * 1. Builds dependency graph (DependencyResolver)
+     * 2. Validates no cycles (CycleDetector)
+     * 3. Generates execution phases (TopologicalSorter)
+     * 4. Packages everything into ExecutionPlan
+     *
+     * @param nodes - Array of execution nodes
+     * @returns Complete execution plan
+     * @throws WorkflowValidationError if dependencies are invalid or cycles exist
+     */
+    static plan(nodes: ExecutionNode[]): ExecutionPlan;
+    /**
+     * Calculate timeout for a phase (max of all node timeouts).
+     * If no timeouts specified, returns undefined.
+     */
+    private static calculatePhaseTimeout;
+    /**
+     * Get execution order (flattened phases).
+     * Returns nodes in the order they should be executed.
+     *
+     * @param plan - Execution plan
+     * @returns Flat array of nodes in execution order
+     */
+    static getFlatOrder(plan: ExecutionPlan): ExecutionNode[];
+    /**
+     * Get nodes that can execute immediately (phase 0).
+     * These are entry points with no dependencies.
+     *
+     * @param plan - Execution plan
+     * @returns Nodes with no dependencies
+     */
+    static getInitialNodes(plan: ExecutionPlan): ExecutionNode[];
+    /**
+     * Get the phase number for a specific step.
+     *
+     * @param plan - Execution plan
+     * @param stepId - Step ID to look up
+     * @returns Phase number (0-indexed) or undefined if not found
+     */
+    static getPhaseForStep(plan: ExecutionPlan, stepId: string): number | undefined;
+    /**
+     * Visualize execution plan as text.
+     * Useful for debugging and understanding execution flow.
+     *
+     * @param plan - Execution plan
+     * @returns Text visualization
+     */
+    static visualize(plan: ExecutionPlan): string;
+    /**
+     * Check if workflow can be parallelized.
+     * Returns true if any phase has more than one step.
+     *
+     * @param plan - Execution plan
+     * @returns True if any steps can run in parallel
+     */
+    static canParallelize(plan: ExecutionPlan): boolean;
+    /**
+     * Get dependency chain for a specific step.
+     * Returns all steps that must complete before this step can run.
+     *
+     * @param plan - Execution plan
+     * @param stepId - Step ID to analyze
+     * @returns Array of step IDs in dependency order
+     */
+    static getDependencyChain(plan: ExecutionPlan, stepId: string): string[];
+    /**
+     * Calculate estimated execution time based on phase timeouts.
+     * This is a rough estimate assuming perfect parallelization.
+     *
+     * @param plan - Execution plan
+     * @returns Estimated execution time in milliseconds
+     */
+    static estimateExecutionTime(plan: ExecutionPlan): number;
+}
+//# sourceMappingURL=ExecutionPlan.d.ts.map

package/dist/execution/ExecutionPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionPlan.d.ts","sourceRoot":"","sources":["../../src/execution/ExecutionPlan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAIL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC3B,MAAM,6BAA6B,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,+BAA+B;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,yCAAyC;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,aAAa,EAAE,CAAC;IAEzC,wDAAwD;IACxD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAE3C,qCAAqC;IACrC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAEhC,4BAA4B;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAE5B,+CAA+C;IAC/C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAEhC,mDAAmD;IACnD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAEpC,8BAA8B;IAC9B,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;CAC5C;AAED;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,aAAa;IAgClD;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAQpC;;;;;;OAMG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,EAAE;IAIzD;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,EAAE;IAO5D;;;;;;OAMG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI/E;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;IAgC7C;;;;;;OAMG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAInD;;;;;;;OAOG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE;IAgCxE;;;;;;OAMG;IACH,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM;CAc1D"}

package/dist/execution/ExecutionPlan.js

@@ -0,0 +1,207 @@
+/**
+ * Execution Plan
+ *
+ * PURE COORDINATION - NO EXECUTION LOGIC.
+ *
+ * This coordinates DependencyResolver, CycleDetector, and TopologicalSorter
+ * to create a valid execution plan. It answers:
+ * - What runs?
+ * - In what order?
+ * - What can run in parallel?
+ * - What are the constraints?
+ *
+ * This is "designing the map, not driving the car."
+ * Execution happens elsewhere (StepExecutor, WorkflowExecutor).
+ *
+ * @module execution
+ */
+import { DependencyResolver, CycleDetector, TopologicalSorter, } from '../graph/DependencyGraph.js';
+/**
+ * Execution plan coordinator.
+ * This orchestrates graph utilities to create execution plans.
+ *
+ * NO EXECUTION LOGIC HERE - only planning and coordination.
+ */
+export class ExecutionPlanner {
+    /**
+     * Create execution plan from execution nodes.
+     *
+     * This is the main entry point. It:
+     * 1. Builds dependency graph (DependencyResolver)
+     * 2. Validates no cycles (CycleDetector)
+     * 3. Generates execution phases (TopologicalSorter)
+     * 4. Packages everything into ExecutionPlan
+     *
+     * @param nodes - Array of execution nodes
+     * @returns Complete execution plan
+     * @throws WorkflowValidationError if dependencies are invalid or cycles exist
+     */
+    static plan(nodes) {
+        // Step 1: Build dependency graph
+        const graph = DependencyResolver.resolve(nodes);
+        // Step 2: Detect cycles (fail fast)
+        CycleDetector.detectAndThrow(graph);
+        // Step 3: Topological sort to get execution phases
+        const sortResult = TopologicalSorter.sort(graph);
+        // Step 4: Build execution phases with nodes and timeouts
+        const phases = sortResult.phases.map((stepIds, index) => {
+            const phaseNodes = stepIds.map((stepId) => graph.nodes.get(stepId));
+            return {
+                phase: index,
+                nodes: Object.freeze(phaseNodes),
+                timeout: this.calculatePhaseTimeout(phaseNodes),
+            };
+        });
+        // Step 5: Package into execution plan
+        return {
+            phases: Object.freeze(phases),
+            graph,
+            totalSteps: nodes.length,
+            maxParallelism: Math.max(...phases.map((p) => p.nodes.length), 0),
+            criticalPathLength: phases.length,
+            sortResult,
+        };
+    }
+    /**
+     * Calculate timeout for a phase (max of all node timeouts).
+     * If no timeouts specified, returns undefined.
+     */
+    static calculatePhaseTimeout(nodes) {
+        const timeouts = nodes
+            .map((node) => node.metadata.timeout)
+            .filter((t) => t !== undefined);
+        return timeouts.length > 0 ? Math.max(...timeouts) : undefined;
+    }
+    /**
+     * Get execution order (flattened phases).
+     * Returns nodes in the order they should be executed.
+     *
+     * @param plan - Execution plan
+     * @returns Flat array of nodes in execution order
+     */
+    static getFlatOrder(plan) {
+        return plan.phases.flatMap((phase) => [...phase.nodes]);
+    }
+    /**
+     * Get nodes that can execute immediately (phase 0).
+     * These are entry points with no dependencies.
+     *
+     * @param plan - Execution plan
+     * @returns Nodes with no dependencies
+     */
+    static getInitialNodes(plan) {
+        if (plan.phases.length === 0) {
+            return [];
+        }
+        return [...plan.phases[0].nodes];
+    }
+    /**
+     * Get the phase number for a specific step.
+     *
+     * @param plan - Execution plan
+     * @param stepId - Step ID to look up
+     * @returns Phase number (0-indexed) or undefined if not found
+     */
+    static getPhaseForStep(plan, stepId) {
+        return plan.sortResult.stepPhases.get(stepId);
+    }
+    /**
+     * Visualize execution plan as text.
+     * Useful for debugging and understanding execution flow.
+     *
+     * @param plan - Execution plan
+     * @returns Text visualization
+     */
+    static visualize(plan) {
+        let output = '📋 Execution Plan\n';
+        output += `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
+        output += `Total Steps: ${plan.totalSteps}\n`;
+        output += `Phases: ${plan.phases.length}\n`;
+        output += `Max Parallelism: ${plan.maxParallelism}\n`;
+        output += `Critical Path: ${plan.criticalPathLength} phases\n\n`;
+        for (const phase of plan.phases) {
+            output += `Phase ${phase.phase}: `;
+            output += `[${[...phase.nodes].map((n) => n.stepId).join(', ')}]`;
+            if (phase.timeout) {
+                output += ` (timeout: ${phase.timeout}ms)`;
+            }
+            output += '\n';
+            // Show adapter references for each node
+            for (const node of phase.nodes) {
+                output += `  └─ ${node.stepId}: ${node.uses}`;
+                if (node.metadata.maxRetries > 0) {
+                    output += ` (retries: ${node.metadata.maxRetries})`;
+                }
+                if (node.metadata.hasCondition) {
+                    output += ` (conditional)`;
+                }
+                output += '\n';
+            }
+        }
+        return output;
+    }
+    /**
+     * Check if workflow can be parallelized.
+     * Returns true if any phase has more than one step.
+     *
+     * @param plan - Execution plan
+     * @returns True if any steps can run in parallel
+     */
+    static canParallelize(plan) {
+        return plan.phases.some((phase) => phase.nodes.length > 1);
+    }
+    /**
+     * Get dependency chain for a specific step.
+     * Returns all steps that must complete before this step can run.
+     *
+     * @param plan - Execution plan
+     * @param stepId - Step ID to analyze
+     * @returns Array of step IDs in dependency order
+     */
+    static getDependencyChain(plan, stepId) {
+        const node = plan.graph.nodes.get(stepId);
+        if (!node) {
+            return [];
+        }
+        const chain = [];
+        const visited = new Set();
+        const visit = (id) => {
+            if (visited.has(id)) {
+                return;
+            }
+            visited.add(id);
+            const currentNode = plan.graph.nodes.get(id);
+            if (!currentNode) {
+                return;
+            }
+            // Visit dependencies first
+            for (const dep of currentNode.dependencies) {
+                visit(dep);
+            }
+            chain.push(id);
+        };
+        visit(stepId);
+        return chain;
+    }
+    /**
+     * Calculate estimated execution time based on phase timeouts.
+     * This is a rough estimate assuming perfect parallelization.
+     *
+     * @param plan - Execution plan
+     * @returns Estimated execution time in milliseconds
+     */
+    static estimateExecutionTime(plan) {
+        let totalTime = 0;
+        for (const phase of plan.phases) {
+            if (phase.timeout) {
+                totalTime += phase.timeout;
+            }
+            else {
+                // If no timeout specified, use a default estimate
+                totalTime += 30000; // 30 seconds default
+            }
+        }
+        return totalTime;
+    }
+}
+//# sourceMappingURL=ExecutionPlan.js.map

package/dist/execution/ExecutionPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecutionPlan.js","sourceRoot":"","sources":["../../src/execution/ExecutionPlan.ts"],"names":[],"mappings":"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"}

package/dist/execution/StepExecutor.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Step Executor
+ *
+ * Executes individual workflow steps with retry logic, timeout handling,
+ * and adapter invocation.
+ *
+ * Integrates with ContextStore for state management and uses automation
+ * policies (RetryPolicy, BackoffStrategy, TimeoutManager) for reliability.
+ *
+ * @module execution
+ */
+import type { ParsedStep } from '../parser/StepParser.js';
+import type { ResolutionContext } from '../context/VariableResolver.js';
+import { ContextStore } from '../context/ContextStore.js';
+import { RetryPolicy } from '../automation/RetryPolicy.js';
+import { TimeoutManager } from '../automation/TimeoutManager.js';
+import { DriverResolver } from './drivers/DriverResolver.js';
+import { AdapterRegistry } from '../adapters/AdapterRegistry.js';
+import type { Adapter } from '@dev-ecosystem/core';
+import type { EventBus } from '../events/EventBus.js';
+import type { HookManager } from '../hooks/HookManager.js';
+/**
+ * Step execution result
+ */
+export interface StepResult {
+    /** Step ID */
+    stepId: string;
+    /** Execution status */
+    status: 'success' | 'failure' | 'skipped' | 'timeout';
+    /** Step output data */
+    output: any;
+    /** Error if failed */
+    error?: Error;
+    /** Execution duration (ms) */
+    duration: number;
+    /** Number of retry attempts */
+    attempts: number;
+    /** Start timestamp */
+    startedAt: Date;
+    /** End timestamp */
+    completedAt: Date;
+}
+/**
+ * Adapter interface for step execution
+ */
+export interface StepAdapter {
+    /** Adapter name */
+    name: string;
+    /**
+     * Execute step with the adapter
+     *
+     * @param action - Full action name (e.g., 'http.request.get')
+     * @param input - Resolved input parameters
+     * @param context - Execution context
+     * @returns Adapter output
+     */
+    execute(action: string, input: Record<string, any>, context: any): Promise<any>;
+}
+/**
+ * Step executor with retry and timeout logic
+ *
+ * Uses driver system for pluggable execution strategies.
+ * Maintains backward compatibility with legacy StepAdapter interface.
+ */
+export declare class StepExecutor {
+    private adapters;
+    private driverResolver;
+    private adapterRegistry;
+    private adapterDriver?;
+    private resolver;
+    private contextStore?;
+    private retryPolicy?;
+    private timeoutManager?;
+    private eventBus?;
+    private hookManager?;
+    /**
+     * Register an adapter (legacy interface - backward compatibility)
+     *
+     * @param adapter - Adapter to register
+     * @deprecated Use registerModernAdapter() for new code
+     */
+    registerAdapter(adapter: StepAdapter): void;
+    /**
+     * Register a modern adapter with driver system
+     *
+     * @param adapter - Adapter implementing @dev-ecosystem/core Adapter interface
+     */
+    registerModernAdapter(adapter: Adapter): void;
+    /**
+     * Register multiple modern adapters
+     *
+     * @param adapters - Array of adapters
+     */
+    registerModernAdapters(adapters: Adapter[]): void;
+    /**
+     * Set context store for state management
+     *
+     * @param contextStore - Context store instance
+     */
+    setContextStore(contextStore: ContextStore): void;
+    /**
+     * Set retry policy for step execution
+     *
+     * @param retryPolicy - Retry policy instance
+     */
+    setRetryPolicy(retryPolicy: RetryPolicy): void;
+    /**
+     * Set timeout manager for step execution
+     *
+     * @param timeoutManager - Timeout manager instance
+     */
+    setTimeoutManager(timeoutManager: TimeoutManager): void;
+    /**
+     * Set event bus for emitting step lifecycle events
+     */
+    setEventBus(eventBus: EventBus): void;
+    /**
+     * Set hook manager for calling lifecycle hooks
+     */
+    setHookManager(hookManager: HookManager): void;
+    /**
+     * Get driver resolver (for advanced use cases)
+     *
+     * @returns Driver resolver instance
+     */
+    getDriverResolver(): DriverResolver;
+    /**
+     * Get adapter registry (for advanced use cases)
+     *
+     * @returns Adapter registry instance
+     */
+    getAdapterRegistry(): AdapterRegistry;
+    /**
+     * Execute a step
+     *
+     * @param step - Step to execute
+     * @param providedContext - Optional resolution context (if not using ContextStore)
+     * @returns Step execution result
+     */
+    execute(step: ParsedStep, providedContext?: ResolutionContext): Promise<StepResult>;
+    /**
+     * Execute step with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Execute using driver system
+     */
+    private executeWithDriver;
+    /**
+     * Execute using legacy adapter (backward compatibility)
+     */
+    private executeWithLegacyAdapter;
+    /**
+     * Convert ParsedStep to DriverStep
+     */
+    private convertToDriverStep;
+    /**
+     * Convert execution context to DriverContext
+     */
+    private convertToDriverContext;
+    /**
+     * Parse timeout string to milliseconds
+     * @param timeout - Timeout string like "30s", "5m", "1h"
+     * @returns Timeout in milliseconds
+     */
+    private parseTimeoutString;
+    /**
+     * Add timeout to promise
+     */
+    private withTimeout;
+    /**
+     * Sleep utility for retry backoff
+     */
+    private sleep;
+    /**
+     * Map raw output to defined output structure
+     *
+     * @param rawOutput - Raw output from adapter
+     * @param outputMappings - Output mapping definitions
+     * @param context - Resolution context for variable resolution in mappings
+     * @returns Mapped output object
+     */
+    private mapOutputs;
+    /**
+     * Evaluate conditional expression
+     *
+     * Currently simple boolean evaluation.
+     * Future: Support expression language.
+     *
+     * @param condition - Conditional expression
+     * @param context - Resolution context
+     * @returns True if condition met
+     */
+    private evaluateCondition;
+    /**
+     * Get registered adapters
+     */
+    getAdapters(): string[];
+    /**
+     * Check if adapter is registered
+     */
+    hasAdapter(name: string): boolean;
+}
+//# sourceMappingURL=StepExecutor.d.ts.map

package/dist/execution/StepExecutor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepExecutor.d.ts","sourceRoot":"","sources":["../../src/execution/StepExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAG7D,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAI3D;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,cAAc;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,uBAAuB;IACvB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAEtD,uBAAuB;IACvB,MAAM,EAAE,GAAG,CAAC;IAEZ,sBAAsB;IACtB,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IAEjB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IAEjB,sBAAsB;IACtB,SAAS,EAAE,IAAI,CAAC;IAEhB,oBAAoB;IACpB,WAAW,EAAE,IAAI,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;CACjF;AAED;;;;;GAKG;AACH,qBAAa,YAAY;IAEvB,OAAO,CAAC,QAAQ,CAAkC;IAGlD,OAAO,CAAC,cAAc,CAAwB;IAC9C,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,aAAa,CAAC,CAAgB;IAEtC,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,cAAc,CAAC,CAAiB;IAGxC,OAAO,CAAC,QAAQ,CAAC,CAAW;IAC5B,OAAO,CAAC,WAAW,CAAC,CAAc;IAElC;;;;;OAKG;IACH,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAI3C;;;;OAIG;IACH,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAU7C;;;;OAIG;IACH,sBAAsB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI;IAMjD;;;;OAIG;IACH,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAIjD;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAI9C;;;;OAIG;IACH,iBAAiB,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI;IAIvD;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAIrC;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI;IAI9C;;;;OAIG;IACH,iBAAiB,IAAI,cAAc;IAInC;;;;OAIG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;;;;;OAMG;IACG,OAAO,CACX,IAAI,EAAE,UAAU,EAChB,eAAe,CAAC,EAAE,iBAAiB,GAClC,OAAO,CAAC,UAAU,CAAC;IAsUtB;;OAEG;YACW,kBAAkB;IA0BhC;;OAEG;YACW,iBAAiB;IAiC/B;;OAEG;YACW,wBAAwB;IAwCtC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAa3B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAmB9B;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAuB1B;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IA4BlB;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IAmBzB;;OAEG;IACH,WAAW,IAAI,MAAM,EAAE;IAIvB;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAGlC"}