@synergenius/flow-weaver 0.2.0

package/dist/utils/port-tag-utils.js

@@ -0,0 +1,41 @@
+/**
+ * Port tag validation utilities
+ * Shared logic for determining port tag types (@input, @output, @step)
+ */
+import { isExecutePort, isSuccessPort, isFailurePort, isScopedMandatoryPort } from "../constants.js";
+/**
+ * Check if a port name is a reserved STEP port.
+ * Includes both external (execute, onSuccess, onFailure) and scoped (start, success, failure).
+ */
+export function isReservedStepPort(name) {
+    return isExecutePort(name) || isSuccessPort(name) || isFailurePort(name) || isScopedMandatoryPort(name);
+}
+/**
+ * Determine if a port should use the @step tag.
+ * Returns true only for custom STEP ports (not reserved ones).
+ */
+export function shouldUseStepTag(portName, port) {
+    if (port.dataType !== "STEP")
+        return false;
+    // Reserved STEP ports use @input/@output, not @step
+    const isExternalReserved = isExecutePort(portName) || isSuccessPort(portName) || isFailurePort(portName);
+    if (isExternalReserved)
+        return false;
+    // Scoped mandatory ports also use @input/@output
+    if (port.scope && isScopedMandatoryPort(portName))
+        return false;
+    return true;
+}
+/**
+ * Get the JSDoc tag type for a port.
+ * - Custom STEP ports → "step"
+ * - Reserved STEP ports → direction ("input" or "output")
+ * - Data ports → direction ("input" or "output")
+ */
+export function getPortTagType(portName, port, direction) {
+    if (shouldUseStepTag(portName, port)) {
+        return "step";
+    }
+    return direction;
+}
+//# sourceMappingURL=port-tag-utils.js.map

package/dist/utils/string-distance.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Levenshtein distance and fuzzy matching utilities
+ */
+/**
+ * Compute the Levenshtein edit distance between two strings.
+ */
+export declare function levenshteinDistance(a: string, b: string): number;
+/**
+ * Find the closest matches from a list of candidates.
+ * Returns candidates within maxDistance, sorted by distance (ascending).
+ * When maxDistance is not provided, uses a length-proportional default.
+ */
+export declare function findClosestMatches(target: string, candidates: string[], maxDistance?: number): string[];
+//# sourceMappingURL=string-distance.d.ts.map

package/dist/utils/string-distance.js

@@ -0,0 +1,56 @@
+/**
+ * Levenshtein distance and fuzzy matching utilities
+ */
+/**
+ * Compute the Levenshtein edit distance between two strings.
+ */
+export function levenshteinDistance(a, b) {
+    const la = a.length;
+    const lb = b.length;
+    if (la === 0)
+        return lb;
+    if (lb === 0)
+        return la;
+    // Use single-row optimization
+    let prev = Array.from({ length: lb + 1 }, (_, i) => i);
+    let curr = new Array(lb + 1);
+    for (let i = 1; i <= la; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= lb; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            curr[j] = Math.min(curr[j - 1] + 1, // insertion
+            prev[j] + 1, // deletion
+            prev[j - 1] + cost // substitution
+            );
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[lb];
+}
+/**
+ * Compute an adaptive max edit distance based on target string length.
+ * Short strings get a tighter threshold to avoid nonsensical suggestions.
+ */
+function adaptiveMaxDistance(target) {
+    const len = target.length;
+    if (len <= 3)
+        return 1;
+    if (len <= 6)
+        return 2;
+    return 3;
+}
+/**
+ * Find the closest matches from a list of candidates.
+ * Returns candidates within maxDistance, sorted by distance (ascending).
+ * When maxDistance is not provided, uses a length-proportional default.
+ */
+export function findClosestMatches(target, candidates, maxDistance) {
+    const effectiveMax = maxDistance ?? adaptiveMaxDistance(target);
+    const scored = candidates
+        .filter((c) => c !== target)
+        .map((c) => ({ name: c, distance: levenshteinDistance(target, c) }))
+        .filter((s) => s.distance <= effectiveMax)
+        .sort((a, b) => a.distance - b.distance);
+    return scored.map((s) => s.name);
+}
+//# sourceMappingURL=string-distance.js.map

package/dist/validation/agent-detection.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent Node Detection
+ *
+ * Multi-signal detection to classify workflow nodes by their agent role.
+ * Uses a priority hierarchy: port signatures > visual annotations > name heuristics.
+ */
+import type { TNodeTypeAST } from '../ast/types.js';
+/**
+ * Recognized agent node roles.
+ * - llm: Calls a language model (has messages/toolCalls/content ports)
+ * - tool-executor: Executes tool calls from an LLM (has toolCall input, result output)
+ * - human-approval: Gates execution on human review (has approved/rejected outputs)
+ * - memory: Stores/retrieves conversation history (has conversationId input, messages output)
+ */
+export type AgentNodeRole = 'llm' | 'tool-executor' | 'human-approval' | 'memory';
+/**
+ * Detect the agent role of a node type using multi-signal analysis.
+ *
+ * Priority:
+ * 1. Port signature patterns (strongest — defines the contract)
+ * 2. @icon annotation (strong — explicit visual intent)
+ * 3. @color annotation (weak — only used to break ties)
+ * 4. Function name heuristics (weakest — fallback only)
+ *
+ * @returns The detected role, or null if the node is not an agent node
+ */
+export declare function detectNodeRole(nodeType: TNodeTypeAST): AgentNodeRole | null;
+/**
+ * Convenience: find all node types in a workflow that match a specific role.
+ * Returns array of [instanceId, nodeType] pairs for all instances with that role.
+ */
+export declare function findNodesByRole(nodeTypes: TNodeTypeAST[], role: AgentNodeRole): TNodeTypeAST[];
+//# sourceMappingURL=agent-detection.d.ts.map

package/dist/validation/agent-detection.js

@@ -0,0 +1,115 @@
+/**
+ * Agent Node Detection
+ *
+ * Multi-signal detection to classify workflow nodes by their agent role.
+ * Uses a priority hierarchy: port signatures > visual annotations > name heuristics.
+ */
+// ---------------------------------------------------------------------------
+// Signal matchers (ordered by priority)
+// ---------------------------------------------------------------------------
+/** Port-based detection — most reliable since port names define the contract */
+const PORT_SIGNATURES = [
+    {
+        // LLM node: has 'messages' input AND ('content' or 'toolCalls' output)
+        role: 'llm',
+        match: (nt) => {
+            const hasMessagesInput = 'messages' in nt.inputs;
+            const hasContentOutput = 'content' in nt.outputs;
+            const hasToolCallsOutput = 'toolCalls' in nt.outputs;
+            return hasMessagesInput && (hasContentOutput || hasToolCallsOutput);
+        },
+    },
+    {
+        // Tool executor: has 'toolCall' input AND 'result' output
+        role: 'tool-executor',
+        match: (nt) => {
+            const hasToolCallInput = 'toolCall' in nt.inputs || 'toolCalls' in nt.inputs;
+            const hasResultOutput = 'result' in nt.outputs || 'resultMessage' in nt.outputs;
+            return hasToolCallInput && hasResultOutput;
+        },
+    },
+    {
+        // Human approval: has ('approved' AND 'rejected') outputs
+        role: 'human-approval',
+        match: (nt) => {
+            return 'approved' in nt.outputs && 'rejected' in nt.outputs;
+        },
+    },
+    {
+        // Memory: has 'conversationId' input AND 'messages' output
+        role: 'memory',
+        match: (nt) => {
+            const hasConversationIdInput = 'conversationId' in nt.inputs;
+            const hasMessagesOutput = 'messages' in nt.outputs;
+            return hasConversationIdInput && hasMessagesOutput;
+        },
+    },
+];
+/** Icon-based detection — reliable when present, from @icon annotation */
+const ICON_MAP = {
+    psychology: 'llm',
+    build: 'tool-executor',
+    verified: 'human-approval',
+    database: 'memory',
+};
+/** Color-based detection — weaker signal, only used to confirm */
+const COLOR_MAP = {
+    purple: 'llm',
+    cyan: 'tool-executor',
+    orange: 'human-approval',
+};
+/** Name pattern heuristics — fallback only */
+const NAME_PATTERNS = [
+    { role: 'llm', pattern: /^(llm|chat|completion|model|ai)/i },
+    { role: 'tool-executor', pattern: /^(tool|action|execute|exec)/i },
+    { role: 'human-approval', pattern: /^(human|approv|review|gate)/i },
+    { role: 'memory', pattern: /^(memory|conversation|history|context)/i },
+];
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Detect the agent role of a node type using multi-signal analysis.
+ *
+ * Priority:
+ * 1. Port signature patterns (strongest — defines the contract)
+ * 2. @icon annotation (strong — explicit visual intent)
+ * 3. @color annotation (weak — only used to break ties)
+ * 4. Function name heuristics (weakest — fallback only)
+ *
+ * @returns The detected role, or null if the node is not an agent node
+ */
+export function detectNodeRole(nodeType) {
+    // 1. Port signatures (highest confidence)
+    for (const sig of PORT_SIGNATURES) {
+        if (sig.match(nodeType)) {
+            return sig.role;
+        }
+    }
+    // 2. Icon annotation
+    const icon = nodeType.visuals?.icon;
+    if (icon && icon in ICON_MAP) {
+        return ICON_MAP[icon];
+    }
+    // 3. Color annotation (only if it maps unambiguously)
+    const color = nodeType.visuals?.color;
+    if (color && color in COLOR_MAP) {
+        return COLOR_MAP[color];
+    }
+    // 4. Function name heuristics
+    const name = nodeType.functionName || nodeType.name;
+    for (const { role, pattern } of NAME_PATTERNS) {
+        if (pattern.test(name)) {
+            return role;
+        }
+    }
+    return null;
+}
+/**
+ * Convenience: find all node types in a workflow that match a specific role.
+ * Returns array of [instanceId, nodeType] pairs for all instances with that role.
+ */
+export function findNodesByRole(nodeTypes, role) {
+    return nodeTypes.filter((nt) => detectNodeRole(nt) === role);
+}
+//# sourceMappingURL=agent-detection.js.map

package/dist/validation/agent-rules.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Agent-Specific Validation Rules
+ *
+ * Custom TValidationRule implementations for agent/AI workflow patterns.
+ * These run AFTER the built-in validator via the api/validate.ts custom rules injection.
+ *
+ * Rules:
+ * 1. AGENT_LLM_MISSING_ERROR_HANDLER - LLM node's onFailure is unconnected
+ * 2. AGENT_UNGUARDED_TOOL_EXECUTOR - Tool executor has no human-approval upstream
+ * 3. AGENT_MISSING_MEMORY_IN_LOOP - Agent loop has LLM but no memory node
+ * 4. AGENT_LLM_NO_FALLBACK - LLM onFailure goes directly to Exit
+ * 5. AGENT_TOOL_NO_OUTPUT_HANDLING - Tool executor outputs are all unconnected
+ */
+import type { TValidationRule } from '../ast/types.js';
+/**
+ * LLM nodes should have their onFailure port connected.
+ * LLM calls are inherently unreliable (rate limits, timeouts, model errors).
+ * An unconnected onFailure means failures are silently swallowed.
+ */
+export declare const missingErrorHandlerRule: TValidationRule;
+/**
+ * Tool executors that perform actions should have a human-approval node upstream.
+ * This is a warning, not an error — read-only tools may not need approval.
+ */
+export declare const unguardedToolExecutorRule: TValidationRule;
+/**
+ * An agent loop (scope) containing an LLM node but no memory node means
+ * the LLM loses context between iterations. This is almost always a bug.
+ */
+export declare const missingMemoryInLoopRule: TValidationRule;
+/**
+ * An LLM node whose onFailure goes directly to Exit.onFailure means
+ * any LLM error immediately aborts the workflow. Consider a retry or fallback.
+ */
+export declare const llmWithoutFallbackRule: TValidationRule;
+/**
+ * A tool executor whose non-STEP output ports are all unconnected means
+ * tool results are computed but never used — likely a wiring mistake.
+ */
+export declare const toolNoOutputHandlingRule: TValidationRule;
+/** All agent validation rules */
+export declare const agentValidationRules: TValidationRule[];
+/**
+ * Get all agent validation rules.
+ * Convenience function for passing to validateWorkflow().
+ */
+export declare function getAgentValidationRules(): TValidationRule[];
+//# sourceMappingURL=agent-rules.d.ts.map

package/dist/validation/agent-rules.js

@@ -0,0 +1,262 @@
+/**
+ * Agent-Specific Validation Rules
+ *
+ * Custom TValidationRule implementations for agent/AI workflow patterns.
+ * These run AFTER the built-in validator via the api/validate.ts custom rules injection.
+ *
+ * Rules:
+ * 1. AGENT_LLM_MISSING_ERROR_HANDLER - LLM node's onFailure is unconnected
+ * 2. AGENT_UNGUARDED_TOOL_EXECUTOR - Tool executor has no human-approval upstream
+ * 3. AGENT_MISSING_MEMORY_IN_LOOP - Agent loop has LLM but no memory node
+ * 4. AGENT_LLM_NO_FALLBACK - LLM onFailure goes directly to Exit
+ * 5. AGENT_TOOL_NO_OUTPUT_HANDLING - Tool executor outputs are all unconnected
+ */
+import { detectNodeRole } from './agent-detection.js';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Resolve a node instance to its node type definition */
+function resolveNodeType(ast, instance) {
+    return ast.nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+}
+/** Get all outgoing connections from a specific port of a node */
+function getOutgoing(ast, nodeId, portName) {
+    return ast.connections.filter((c) => {
+        if (c.from.node !== nodeId)
+            return false;
+        if (portName && c.from.port !== portName)
+            return false;
+        return true;
+    });
+}
+/** Get all instances whose node type has a given agent role */
+function getInstancesByRole(ast, role) {
+    const results = [];
+    for (const instance of ast.instances) {
+        const nt = resolveNodeType(ast, instance);
+        if (nt && detectNodeRole(nt) === role) {
+            results.push({ instance, nodeType: nt });
+        }
+    }
+    return results;
+}
+/**
+ * Get all transitive upstream node IDs for a given node.
+ * Walks backwards through connections (BFS).
+ */
+function getUpstreamNodes(ast, nodeId) {
+    const visited = new Set();
+    const queue = [nodeId];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        for (const conn of ast.connections) {
+            if (conn.to.node === current && !visited.has(conn.from.node)) {
+                queue.push(conn.from.node);
+            }
+        }
+    }
+    visited.delete(nodeId); // exclude self
+    return visited;
+}
+// ---------------------------------------------------------------------------
+// Rule 1: Missing Error Handler
+// ---------------------------------------------------------------------------
+/**
+ * LLM nodes should have their onFailure port connected.
+ * LLM calls are inherently unreliable (rate limits, timeouts, model errors).
+ * An unconnected onFailure means failures are silently swallowed.
+ */
+export const missingErrorHandlerRule = {
+    name: 'AGENT_LLM_MISSING_ERROR_HANDLER',
+    validate(ast) {
+        const errors = [];
+        const llmInstances = getInstancesByRole(ast, 'llm');
+        for (const { instance, nodeType } of llmInstances) {
+            // Only check if the node type has an onFailure port
+            if (!nodeType.hasFailurePort && !('onFailure' in nodeType.outputs)) {
+                continue;
+            }
+            const failureConnections = getOutgoing(ast, instance.id, 'onFailure');
+            if (failureConnections.length === 0) {
+                errors.push({
+                    type: 'error',
+                    code: 'AGENT_LLM_MISSING_ERROR_HANDLER',
+                    message: `LLM node '${instance.id}' has no error handler — its onFailure port is unconnected. LLM calls can fail due to rate limits, timeouts, or model errors.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 2: Unguarded Tool Executor
+// ---------------------------------------------------------------------------
+/**
+ * Tool executors that perform actions should have a human-approval node upstream.
+ * This is a warning, not an error — read-only tools may not need approval.
+ */
+export const unguardedToolExecutorRule = {
+    name: 'AGENT_UNGUARDED_TOOL_EXECUTOR',
+    validate(ast) {
+        const errors = [];
+        const toolInstances = getInstancesByRole(ast, 'tool-executor');
+        const approvalInstances = getInstancesByRole(ast, 'human-approval');
+        // If no tool executors, nothing to check
+        if (toolInstances.length === 0)
+            return errors;
+        // If no approval nodes at all, warn for every tool executor
+        if (approvalInstances.length === 0) {
+            for (const { instance } of toolInstances) {
+                errors.push({
+                    type: 'warning',
+                    code: 'AGENT_UNGUARDED_TOOL_EXECUTOR',
+                    message: `Tool executor '${instance.id}' has no human approval gate upstream. If this node performs destructive actions, consider adding a human-approval node before it.`,
+                    node: instance.id,
+                });
+            }
+            return errors;
+        }
+        // Check each tool executor for upstream approval
+        for (const { instance: toolInstance } of toolInstances) {
+            const upstream = getUpstreamNodes(ast, toolInstance.id);
+            const hasUpstreamApproval = approvalInstances.some(({ instance: approvalInstance }) => upstream.has(approvalInstance.id));
+            if (!hasUpstreamApproval) {
+                errors.push({
+                    type: 'warning',
+                    code: 'AGENT_UNGUARDED_TOOL_EXECUTOR',
+                    message: `Tool executor '${toolInstance.id}' has no human approval gate upstream. If this node performs destructive actions, consider adding a human-approval node before it.`,
+                    node: toolInstance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 3: Missing Memory in Loop
+// ---------------------------------------------------------------------------
+/**
+ * An agent loop (scope) containing an LLM node but no memory node means
+ * the LLM loses context between iterations. This is almost always a bug.
+ */
+export const missingMemoryInLoopRule = {
+    name: 'AGENT_MISSING_MEMORY_IN_LOOP',
+    validate(ast) {
+        const errors = [];
+        if (!ast.scopes)
+            return errors;
+        for (const [scopeName, instanceIds] of Object.entries(ast.scopes)) {
+            let hasLlm = false;
+            let hasMemory = false;
+            for (const instId of instanceIds) {
+                const instance = ast.instances.find((i) => i.id === instId);
+                if (!instance)
+                    continue;
+                const nt = resolveNodeType(ast, instance);
+                if (!nt)
+                    continue;
+                const role = detectNodeRole(nt);
+                if (role === 'llm')
+                    hasLlm = true;
+                if (role === 'memory')
+                    hasMemory = true;
+            }
+            if (hasLlm && !hasMemory) {
+                errors.push({
+                    type: 'warning',
+                    code: 'AGENT_MISSING_MEMORY_IN_LOOP',
+                    message: `Scope '${scopeName}' contains an LLM node but no conversation memory node. The LLM will lose context between loop iterations.`,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 4: LLM Without Fallback
+// ---------------------------------------------------------------------------
+/**
+ * An LLM node whose onFailure goes directly to Exit.onFailure means
+ * any LLM error immediately aborts the workflow. Consider a retry or fallback.
+ */
+export const llmWithoutFallbackRule = {
+    name: 'AGENT_LLM_NO_FALLBACK',
+    validate(ast) {
+        const errors = [];
+        const llmInstances = getInstancesByRole(ast, 'llm');
+        for (const { instance, nodeType } of llmInstances) {
+            if (!nodeType.hasFailurePort && !('onFailure' in nodeType.outputs)) {
+                continue;
+            }
+            const failureConnections = getOutgoing(ast, instance.id, 'onFailure');
+            // If unconnected, Rule 1 handles it — skip here
+            if (failureConnections.length === 0)
+                continue;
+            // Check if ALL failure connections go directly to Exit
+            const allToExit = failureConnections.every((c) => c.to.node === 'Exit');
+            if (allToExit) {
+                errors.push({
+                    type: 'warning',
+                    code: 'AGENT_LLM_NO_FALLBACK',
+                    message: `LLM node '${instance.id}' routes failures directly to Exit. Consider adding a retry node or fallback LLM provider for resilience.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 5: Tool Executor No Output Handling
+// ---------------------------------------------------------------------------
+/**
+ * A tool executor whose non-STEP output ports are all unconnected means
+ * tool results are computed but never used — likely a wiring mistake.
+ */
+export const toolNoOutputHandlingRule = {
+    name: 'AGENT_TOOL_NO_OUTPUT_HANDLING',
+    validate(ast) {
+        const errors = [];
+        const toolInstances = getInstancesByRole(ast, 'tool-executor');
+        const stepPorts = new Set(['onSuccess', 'onFailure', 'execute']);
+        for (const { instance, nodeType } of toolInstances) {
+            const dataPorts = Object.keys(nodeType.outputs).filter((p) => !stepPorts.has(p));
+            // If no data ports, nothing to check
+            if (dataPorts.length === 0)
+                continue;
+            const hasAnyConnected = dataPorts.some((port) => getOutgoing(ast, instance.id, port).length > 0);
+            if (!hasAnyConnected) {
+                errors.push({
+                    type: 'warning',
+                    code: 'AGENT_TOOL_NO_OUTPUT_HANDLING',
+                    message: `Tool executor '${instance.id}' has no data output ports connected. Tool results (${dataPorts.join(', ')}) are being discarded.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** All agent validation rules */
+export const agentValidationRules = [
+    missingErrorHandlerRule,
+    unguardedToolExecutorRule,
+    missingMemoryInLoopRule,
+    llmWithoutFallbackRule,
+    toolNoOutputHandlingRule,
+];
+/**
+ * Get all agent validation rules.
+ * Convenience function for passing to validateWorkflow().
+ */
+export function getAgentValidationRules() {
+    return agentValidationRules;
+}
+//# sourceMappingURL=agent-rules.js.map

package/dist/validator.d.ts

@@ -0,0 +1,92 @@
+import type { TNodeTypeAST, TWorkflowAST, TValidationError } from './ast/types.js';
+export type { TValidationError } from './ast/types.js';
+export declare class WorkflowValidator {
+    private errors;
+    private warnings;
+    private strictMode;
+    /** Look up instance sourceLocation by instance ID */
+    private getInstanceLocation;
+    /** Look up connection sourceLocation */
+    private getConnectionLocation;
+    /**
+     * Validate a single node type for scoped port requirements
+     *
+     * Scoped Port Architecture Rules:
+     * - Scope names must be valid JavaScript identifiers
+     *
+     * Per-Port Scope Architecture:
+     * - Scoped OUTPUT ports become callback PARAMETERS (data flows to children)
+     * - Scoped INPUT ports become callback RETURN VALUES (data flows from children)
+     * - Scoped ports can be ANY data type - they're not functions themselves
+     * - The callback function is passed as a function parameter (e.g., forEach's itemProcessor)
+     *
+     * NOTE: execute/onSuccess/onFailure ports are mandatory base interface ports
+     * that are auto-added to ALL nodes - no validation needed for those.
+     */
+    validateNodeType(nodeType: TNodeTypeAST): string[];
+    validate(workflow: TWorkflowAST, options?: {
+        strictMode?: boolean;
+    }): {
+        valid: boolean;
+        errors: TValidationError[];
+        warnings: TValidationError[];
+    };
+    private validateStructure;
+    private validateDuplicateNodeNames;
+    private validateMutableBindings;
+    private validateReservedNames;
+    private validateConnections;
+    /**
+     * Validate type compatibility for connections with coercion support
+     *
+     * Type coercion rules:
+     * - ANY type connections always allowed (no warning)
+     * - Safe coercions: NUMBER → STRING, BOOLEAN → STRING (no warning)
+     * - Lossy coercions: STRING → NUMBER, STRING → BOOLEAN, OBJECT → STRING (warning or error in strict mode)
+     * - Unusual coercions: NUMBER → BOOLEAN, BOOLEAN → NUMBER (warning or error in strict mode)
+     * - Same type connections always allowed (no warning)
+     *
+     * Strict types mode (@strictTypes):
+     * - When enabled, type incompatibilities are errors instead of warnings
+     */
+    private validateTypeCompatibility;
+    private validateNodeReferences;
+    private validateRequiredInputs;
+    private detectUnusedNodes;
+    private validateStartAndExit;
+    /**
+     * Validate data flow in the workflow
+     *
+     * Checks for:
+     * - Unused output ports (data produced but never consumed)
+     * - Unreachable Exit ports (Exit expects data but no connection provides it)
+     * - Dead-end data paths (data that never reaches Exit)
+     */
+    private validateDataFlow;
+    /**
+     * Validate for cycles (loops) in the workflow graph.
+     * Cycles are connections that form a loop back to an earlier node.
+     * Scoped nodes handle loops internally, so cycles within same scope are checked.
+     */
+    private validateCycles;
+    private detectCyclesInLayer;
+    /**
+     * Validate that no input port has multiple connections.
+     * Only one value can be received per input port.
+     * (STEP ports can have multiple connections as they're control flow)
+     */
+    private validateMultipleInputConnections;
+    /**
+     * Cross-check @input annotations against TypeScript function signatures.
+     * Warns on optionality and type mismatches between annotations and actual code.
+     */
+    private validateAnnotationSignatureConsistency;
+    /**
+     * Check if a set of source nodes are mutually exclusive — i.e., they descend
+     * from opposite branches (onSuccess vs onFailure) of the same branching node.
+     */
+    private areMutuallyExclusive;
+    private normalizeTypeString;
+}
+export declare const validator: WorkflowValidator;
+//# sourceMappingURL=validator.d.ts.map