@synergenius/flow-weaver 0.20.4 → 0.20.6

package/dist/doc-metadata/extractors/error-codes.js

@@ -318,5 +318,55 @@ export const VALIDATION_CODES = [
         description: 'Tool executor data outputs all unconnected',
         category: 'agent',
     },
+    // ── Design ──────────────────────────────────────────────────────────
+    {
+        code: 'DESIGN_ASYNC_NO_ERROR_PATH',
+        severity: 'warning',
+        title: 'Async Node Missing Error Path',
+        description: 'Async node has no onFailure connection',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_SCOPE_NO_FAILURE_EXIT',
+        severity: 'warning',
+        title: 'Scope Missing Failure Exit',
+        description: 'Scope node has no failure path out',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_UNBOUNDED_RETRY',
+        severity: 'warning',
+        title: 'Unbounded Retry Loop',
+        description: 'Retry scope has no visible attempt limit',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_FANOUT_NO_FANIN',
+        severity: 'warning',
+        title: 'Fan-Out Without Fan-In',
+        description: 'Fan-out to multiple step targets with no merge back',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_EXIT_DATA_UNREACHABLE',
+        severity: 'warning',
+        title: 'Exit Data Unreachable',
+        description: 'Exit data port has no connection and no pull-execution provider',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_PULL_CANDIDATE',
+        severity: 'warning',
+        title: 'Pull Execution Candidate',
+        description: 'Node has no step trigger but its outputs are consumed downstream',
+        category: 'design',
+    },
+    {
+        code: 'DESIGN_PULL_UNUSED',
+        severity: 'warning',
+        title: 'Unused Pull Execution',
+        description: 'Pull-execution node has no downstream consumers',
+        category: 'design',
+    },
 ];
 //# sourceMappingURL=error-codes.js.map

package/dist/friendly-errors.js

@@ -505,6 +505,71 @@ const errorMappers = {
             code: error.code,
         };
     },
+    // ── Design quality rules ─────────────────────────────────────────────
+    DESIGN_ASYNC_NO_ERROR_PATH(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Async Node Missing Error Path',
+            explanation: `Async node '${nodeName}' has no onFailure connection. Async operations (network calls, file I/O, AI calls) can fail, and errors will be silently lost.`,
+            fix: `Connect ${nodeName}.onFailure to an error handler, retry node, or Exit.onFailure.`,
+            code: error.code,
+        };
+    },
+    DESIGN_SCOPE_NO_FAILURE_EXIT(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Scope Missing Failure Exit',
+            explanation: `Scope node '${nodeName}' has no failure path out. If all iterations fail, execution stalls with no error surfaced upstream.`,
+            fix: `Connect ${nodeName}.onFailure to an error handler or Exit.onFailure so scope failures propagate.`,
+            code: error.code,
+        };
+    },
+    DESIGN_UNBOUNDED_RETRY(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Unbounded Retry Loop',
+            explanation: `Scope node '${nodeName}' looks like a retry loop but has no visible attempt limit input. This could loop indefinitely on persistent failures.`,
+            fix: `Add a maxAttempts or retries input port to the node type, or use a counter to break out of the loop after N attempts.`,
+            code: error.code,
+        };
+    },
+    DESIGN_FANOUT_NO_FANIN(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Fan-Out Without Fan-In',
+            explanation: `Node '${nodeName}' fans out to multiple step targets, but those paths never merge back to a shared downstream node. Data from parallel branches may be lost.`,
+            fix: `Add a merge node downstream where the parallel branches converge, or wire them to a shared node before Exit.`,
+            code: error.code,
+        };
+    },
+    DESIGN_EXIT_DATA_UNREACHABLE(error) {
+        const quoted = extractQuoted(error.message);
+        const portName = quoted[0] || 'unknown';
+        return {
+            title: 'Exit Data Unreachable',
+            explanation: `Exit port '${portName}' has no incoming data connection and no pull-execution node provides it. The workflow will return undefined for this output.`,
+            fix: `Connect a node's data output to Exit.${portName}, or add a pull-execution node that computes this value on demand.`,
+            code: error.code,
+        };
+    },
+    DESIGN_PULL_CANDIDATE(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Pull Execution Candidate',
+            explanation: `Node '${nodeName}' has no incoming step connection but its data outputs are consumed downstream. Without a step trigger or pullExecution, this node may never execute.`,
+            fix: `Add [pullExecution: execute] to the @node annotation so the node runs on demand when downstream nodes read its output.`,
+            code: error.code,
+        };
+    },
+    DESIGN_PULL_UNUSED(error) {
+        const nodeName = error.node || 'unknown';
+        return {
+            title: 'Unused Pull Execution',
+            explanation: `Node '${nodeName}' is marked with pullExecution but no downstream node reads its data output. The node will never execute since pull execution requires a consumer.`,
+            fix: `Connect a data output from '${nodeName}' to a downstream node, or remove the pullExecution config if the node isn't needed.`,
+            code: error.code,
+        };
+    },
     COERCE_TYPE_MISMATCH(error) {
         const coerceMatch = error.message.match(/`as (\w+)`/);
         const coerceType = coerceMatch?.[1] || 'unknown';

package/dist/generated-version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.20.4";
+export declare const VERSION = "0.20.6";
 //# sourceMappingURL=generated-version.d.ts.map

package/dist/generated-version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.ts — do not edit manually
-export const VERSION = '0.20.4';
+export const VERSION = '0.20.6';
 //# sourceMappingURL=generated-version.js.map

package/dist/generator/code-utils.js

@@ -255,23 +255,40 @@ export function buildNodeArgumentsWithContext(opts) {
                 const isConstSource = isStartNode(sourceNode) || sourceNode === instanceParent;
                 const nonNullAssert = isConstSource ? '' : '!';
                 const portType = mapToTypeScript(portConfig.dataType, portConfig.tsType);
+                // For optional ports on non-const sources, guard against undefined execution index.
+                // This is critical for DISJUNCTION nodes where the source may not have executed.
+                const needsGuard = portConfig.optional && !isConstSource;
                 // For FUNCTION type ports, add resolution step to handle registry IDs
                 if (portConfig.dataType === 'FUNCTION') {
                     const rawVarName = `${varName}_raw`;
-                    lines.push(`${indent}const ${rawVarName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} });`);
-                    lines.push(`${indent}const ${varName}_resolved = resolveFunction(${rawVarName});`);
-                    lines.push(`${indent}const ${varName} = ${varName}_resolved.fn as ${portType};`);
+                    if (needsGuard) {
+                        lines.push(`${indent}const ${rawVarName} = ${sourceIdx} !== undefined ? ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} }) : undefined;`);
+                        lines.push(`${indent}const ${varName}_resolved = ${rawVarName} !== undefined ? resolveFunction(${rawVarName}) : undefined;`);
+                        lines.push(`${indent}const ${varName} = ${varName}_resolved?.fn as ${portType};`);
+                    }
+                    else {
+                        lines.push(`${indent}const ${rawVarName} = ${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} });`);
+                        lines.push(`${indent}const ${varName}_resolved = resolveFunction(${rawVarName});`);
+                        lines.push(`${indent}const ${varName} = ${varName}_resolved.fn as ${portType};`);
+                    }
                 }
                 else {
                     // Check for coercion (explicit or auto)
                     const sourceDataType = resolveSourcePortDataType(workflow, sourceNode, sourcePort);
                     const coerceExpr = getCoercionWrapper(connection, sourceDataType, portConfig.dataType);
-                    const getExpr = `${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} })`;
-                    if (coerceExpr) {
-                        lines.push(`${indent}const ${varName} = ${coerceExpr}(${getExpr}) as ${portType};`);
+                    if (needsGuard) {
+                        const getExpr = `${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx} })`;
+                        const wrappedExpr = coerceExpr ? `${coerceExpr}(${getExpr})` : getExpr;
+                        lines.push(`${indent}const ${varName} = ${sourceIdx} !== undefined ? ${wrappedExpr} as ${portType} : undefined;`);
                     }
                     else {
-                        lines.push(`${indent}const ${varName} = ${getExpr} as ${portType};`);
+                        const getExpr = `${getCall}({ id: '${sourceNode}', portName: '${sourcePort}', executionIndex: ${sourceIdx}${nonNullAssert} })`;
+                        if (coerceExpr) {
+                            lines.push(`${indent}const ${varName} = ${coerceExpr}(${getExpr}) as ${portType};`);
+                        }
+                        else {
+                            lines.push(`${indent}const ${varName} = ${getExpr} as ${portType};`);
+                        }
                     }
                 }
             }

package/dist/mcp/response-utils.js

@@ -55,6 +55,14 @@ export const ERROR_HINTS = {
     AGENT_MISSING_MEMORY_IN_LOOP: 'Add a conversation-memory node inside the loop scope. Use fw_scaffold(template="conversation-memory") to create one',
     AGENT_LLM_NO_FALLBACK: 'Add a retry or fallback node between the LLM onFailure and Exit. Consider a second LLM provider as fallback',
     AGENT_TOOL_NO_OUTPUT_HANDLING: 'Use fw_modify(operation="addConnection") to wire tool output ports to downstream nodes',
+    // Design quality rules
+    DESIGN_ASYNC_NO_ERROR_PATH: 'Use fw_modify(operation="addConnection", params={from:"<nodeId>.onFailure", to:"Exit.onFailure"}) or add a retry/error handler',
+    DESIGN_SCOPE_NO_FAILURE_EXIT: 'Use fw_modify(operation="addConnection", params={from:"<nodeId>.onFailure", to:"Exit.onFailure"}) to surface scope failures',
+    DESIGN_UNBOUNDED_RETRY: 'Add a maxAttempts or retries input port to the retry node type to bound the loop',
+    DESIGN_FANOUT_NO_FANIN: 'Add a merge node downstream where parallel branches converge before Exit',
+    DESIGN_EXIT_DATA_UNREACHABLE: 'Use fw_modify(operation="addConnection") to connect a node output to this Exit port, or add a pull-execution node',
+    DESIGN_PULL_CANDIDATE: 'Add [pullExecution: execute] to the @node annotation so the node runs on demand',
+    DESIGN_PULL_UNUSED: 'Connect a data output from this node to a downstream consumer, or remove pullExecution',
 };
 /**
  * Enriches validation items with actionable hints from {@link ERROR_HINTS} and optional

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

@@ -0,0 +1,61 @@
+/**
+ * Design Quality Validation Rules
+ *
+ * Deterministic, AST-inspectable rules that catch common workflow design problems.
+ * A workflow can compile fine and still be poorly designed: missing error paths,
+ * unbounded retries, fan-out without fan-in, dead-end branches.
+ *
+ * All rules are warnings or info. None block compilation.
+ * Users can suppress any with @suppress.
+ *
+ * Rules:
+ * 1. DESIGN_ASYNC_NO_ERROR_PATH - Async node has no onFailure connection
+ * 2. DESIGN_SCOPE_NO_FAILURE_EXIT - Scope has no failure path out
+ * 3. DESIGN_UNBOUNDED_RETRY - Retry scope has no visible attempt limit
+ * 4. DESIGN_FANOUT_NO_FANIN - Fan-out to step targets with no merge back
+ * 5. DESIGN_EXIT_DATA_UNREACHABLE - Exit data port has no connection and no pull-execution provider
+ * 6. DESIGN_PULL_CANDIDATE - Node with no incoming step but consumed data outputs
+ * 7. DESIGN_PULL_UNUSED - Node marked pullExecution but no downstream reads its output
+ */
+import type { TValidationRule } from '../ast/types.js';
+/**
+ * Async nodes (network, disk, AI) can fail. If onFailure is unconnected,
+ * failures may be silently swallowed or crash the workflow.
+ */
+export declare const asyncNoErrorPathRule: TValidationRule;
+/**
+ * A scope (retry/forEach) with no failure path out means if every iteration
+ * fails, execution stalls with no way to surface the error.
+ */
+export declare const scopeNoFailureExitRule: TValidationRule;
+/**
+ * A scope used as a retry loop without a visible attempt limit could loop
+ * indefinitely. Check if the parent node type name/function suggests retry
+ * semantics but lacks a maxAttempts-like input or config.
+ */
+export declare const unboundedRetryRule: TValidationRule;
+/**
+ * A node that fans out via step connections to multiple targets, but none of
+ * those paths merge back to a shared downstream node. Data from parallel
+ * branches may be lost.
+ */
+export declare const fanoutNoFaninRule: TValidationRule;
+/**
+ * Extends UNREACHABLE_EXIT_PORT to consider pull execution. An exit data port
+ * is fine if a pull-executed node is wired to provide it, even without a
+ * step path.
+ */
+export declare const exitDataUnreachableRule: TValidationRule;
+/**
+ * A node with no incoming step connections but data outputs consumed downstream
+ * is a candidate for pullExecution. Without it, the node may never execute.
+ */
+export declare const pullCandidateRule: TValidationRule;
+/**
+ * A node marked with pullExecution but no downstream node reads its data output.
+ * The node will never execute since pull execution requires a consumer.
+ */
+export declare const pullUnusedRule: TValidationRule;
+export declare const designValidationRules: TValidationRule[];
+export declare function getDesignValidationRules(): TValidationRule[];
+//# sourceMappingURL=design-rules.d.ts.map

package/dist/validation/design-rules.js

@@ -0,0 +1,377 @@
+/**
+ * Design Quality Validation Rules
+ *
+ * Deterministic, AST-inspectable rules that catch common workflow design problems.
+ * A workflow can compile fine and still be poorly designed: missing error paths,
+ * unbounded retries, fan-out without fan-in, dead-end branches.
+ *
+ * All rules are warnings or info. None block compilation.
+ * Users can suppress any with @suppress.
+ *
+ * Rules:
+ * 1. DESIGN_ASYNC_NO_ERROR_PATH - Async node has no onFailure connection
+ * 2. DESIGN_SCOPE_NO_FAILURE_EXIT - Scope has no failure path out
+ * 3. DESIGN_UNBOUNDED_RETRY - Retry scope has no visible attempt limit
+ * 4. DESIGN_FANOUT_NO_FANIN - Fan-out to step targets with no merge back
+ * 5. DESIGN_EXIT_DATA_UNREACHABLE - Exit data port has no connection and no pull-execution provider
+ * 6. DESIGN_PULL_CANDIDATE - Node with no incoming step but consumed data outputs
+ * 7. DESIGN_PULL_UNUSED - Node marked pullExecution but no downstream reads its output
+ */
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function resolveNodeType(ast, instance) {
+    return ast.nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+}
+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;
+    });
+}
+function getIncoming(ast, nodeId, portName) {
+    return ast.connections.filter((c) => {
+        if (c.to.node !== nodeId)
+            return false;
+        if (portName && c.to.port !== portName)
+            return false;
+        return true;
+    });
+}
+const STEP_PORTS = new Set(['execute', 'onSuccess', 'onFailure', 'start', 'success', 'failure']);
+function isStepPort(portName, portDef) {
+    if (portDef?.dataType === 'STEP')
+        return true;
+    return STEP_PORTS.has(portName);
+}
+// ---------------------------------------------------------------------------
+// Rule 1: Async Node Missing Error Path
+// ---------------------------------------------------------------------------
+/**
+ * Async nodes (network, disk, AI) can fail. If onFailure is unconnected,
+ * failures may be silently swallowed or crash the workflow.
+ */
+export const asyncNoErrorPathRule = {
+    name: 'DESIGN_ASYNC_NO_ERROR_PATH',
+    validate(ast) {
+        const errors = [];
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            if (!nt)
+                continue;
+            if (!nt.isAsync)
+                continue;
+            if (!nt.hasFailurePort)
+                continue;
+            const failureConns = getOutgoing(ast, instance.id, 'onFailure');
+            if (failureConns.length === 0) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_ASYNC_NO_ERROR_PATH',
+                    message: `Async node '${instance.id}' has no onFailure connection. Async operations (network, disk, AI) can fail, and errors will be silently lost.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 2: Scope With No Failure Exit
+// ---------------------------------------------------------------------------
+/**
+ * A scope (retry/forEach) with no failure path out means if every iteration
+ * fails, execution stalls with no way to surface the error.
+ */
+export const scopeNoFailureExitRule = {
+    name: 'DESIGN_SCOPE_NO_FAILURE_EXIT',
+    validate(ast) {
+        const errors = [];
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            if (!nt)
+                continue;
+            // Only check nodes that define scopes
+            const scopeNames = nt.scopes ?? (nt.scope ? [nt.scope] : []);
+            if (scopeNames.length === 0)
+                continue;
+            // A scope parent needs an onFailure or failure port connected
+            if (!nt.hasFailurePort)
+                continue;
+            const failureConns = getOutgoing(ast, instance.id, 'onFailure');
+            // Also check 'failure' port used in some scope patterns
+            const failureConns2 = getOutgoing(ast, instance.id, 'failure');
+            if (failureConns.length === 0 && failureConns2.length === 0) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_SCOPE_NO_FAILURE_EXIT',
+                    message: `Scope node '${instance.id}' has no failure path out. If all iterations fail, execution stalls with no error surfaced.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 3: Unbounded Retry
+// ---------------------------------------------------------------------------
+/**
+ * A scope used as a retry loop without a visible attempt limit could loop
+ * indefinitely. Check if the parent node type name/function suggests retry
+ * semantics but lacks a maxAttempts-like input or config.
+ */
+export const unboundedRetryRule = {
+    name: 'DESIGN_UNBOUNDED_RETRY',
+    validate(ast) {
+        const errors = [];
+        const retryPatterns = /retry|repeat|loop|poll|backoff/i;
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            if (!nt)
+                continue;
+            const scopeNames = nt.scopes ?? (nt.scope ? [nt.scope] : []);
+            if (scopeNames.length === 0)
+                continue;
+            // Only flag nodes that look like retry patterns
+            const nameHint = `${nt.name} ${nt.functionName} ${nt.label ?? ''}`;
+            if (!retryPatterns.test(nameHint))
+                continue;
+            // Check for a maxAttempts/retries/limit input port
+            const limitInputs = Object.keys(nt.inputs).filter((p) => /max|limit|attempts|retries|count/i.test(p));
+            if (limitInputs.length === 0) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_UNBOUNDED_RETRY',
+                    message: `Scope node '${instance.id}' appears to be a retry loop but has no visible attempt limit input. This could loop indefinitely.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 4: Fan-Out Without Fan-In
+// ---------------------------------------------------------------------------
+/**
+ * A node that fans out via step connections to multiple targets, but none of
+ * those paths merge back to a shared downstream node. Data from parallel
+ * branches may be lost.
+ */
+export const fanoutNoFaninRule = {
+    name: 'DESIGN_FANOUT_NO_FANIN',
+    validate(ast) {
+        const errors = [];
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            // Find step output connections (excluding data ports)
+            const stepOutConns = getOutgoing(ast, instance.id).filter((c) => {
+                if (nt) {
+                    const portDef = nt.outputs[c.from.port];
+                    return isStepPort(c.from.port, portDef);
+                }
+                return isStepPort(c.from.port);
+            });
+            // Get unique step targets (excluding Exit, which is a natural terminus)
+            const stepTargets = [...new Set(stepOutConns.map((c) => c.to.node))].filter((n) => n !== 'Exit');
+            // Need at least 3 targets to be a meaningful fan-out (2 is just success/failure branching)
+            if (stepTargets.length < 3)
+                continue;
+            // For each target, walk forward to find all reachable nodes
+            const reachableSets = stepTargets.map((target) => getReachableNodes(ast, target));
+            // Check if any node appears in multiple reachable sets (fan-in point)
+            const allNodes = new Set();
+            let hasMerge = false;
+            for (const reachable of reachableSets) {
+                for (const node of reachable) {
+                    if (allNodes.has(node)) {
+                        hasMerge = true;
+                        break;
+                    }
+                }
+                if (hasMerge)
+                    break;
+                for (const node of reachable) {
+                    allNodes.add(node);
+                }
+            }
+            // Also check if any target has a merge strategy on its input ports
+            if (!hasMerge) {
+                for (const target of stepTargets) {
+                    const targetInst = ast.instances.find((i) => i.id === target);
+                    if (!targetInst)
+                        continue;
+                    const targetNt = resolveNodeType(ast, targetInst);
+                    if (!targetNt)
+                        continue;
+                    const hasMergePort = Object.values(targetNt.inputs).some((p) => p.mergeStrategy);
+                    if (hasMergePort) {
+                        hasMerge = true;
+                        break;
+                    }
+                }
+            }
+            if (!hasMerge) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_FANOUT_NO_FANIN',
+                    message: `Node '${instance.id}' fans out to ${stepTargets.length} step targets (${stepTargets.join(', ')}) but those paths never merge back. Data from parallel branches may be lost.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+/** Walk forward from a node to find all reachable nodes (BFS via step connections). */
+function getReachableNodes(ast, startNode) {
+    const visited = new Set();
+    const queue = [startNode];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current))
+            continue;
+        visited.add(current);
+        for (const conn of ast.connections) {
+            if (conn.from.node === current && !visited.has(conn.to.node)) {
+                queue.push(conn.to.node);
+            }
+        }
+    }
+    return visited;
+}
+// ---------------------------------------------------------------------------
+// Rule 5: Exit Data Port Unreachable (Pull-Execution Aware)
+// ---------------------------------------------------------------------------
+/**
+ * Extends UNREACHABLE_EXIT_PORT to consider pull execution. An exit data port
+ * is fine if a pull-executed node is wired to provide it, even without a
+ * step path.
+ */
+export const exitDataUnreachableRule = {
+    name: 'DESIGN_EXIT_DATA_UNREACHABLE',
+    validate(ast) {
+        const errors = [];
+        const stepPorts = new Set(['onSuccess', 'onFailure']);
+        for (const [portName, portDef] of Object.entries(ast.exitPorts)) {
+            if (portDef.dataType === 'STEP')
+                continue; // Step ports handled by core validator
+            const incoming = getIncoming(ast, 'Exit', portName);
+            if (incoming.length > 0)
+                continue; // Has a direct connection, fine
+            // Check if a pull-executed node provides this port
+            const hasPullProvider = ast.instances.some((inst) => {
+                const isPull = inst.config?.pullExecution ||
+                    resolveNodeType(ast, inst)?.defaultConfig?.pullExecution;
+                if (!isPull)
+                    return false;
+                // Check if this pull node has a data output connected to Exit.<portName>
+                return getOutgoing(ast, inst.id).some((c) => c.to.node === 'Exit' && c.to.port === portName);
+            });
+            if (!hasPullProvider) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_EXIT_DATA_UNREACHABLE',
+                    message: `Exit port '${portName}' has no incoming connection and no pull-execution node provides it. The output will be undefined.`,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 6: Pull Execution Candidate
+// ---------------------------------------------------------------------------
+/**
+ * A node with no incoming step connections but data outputs consumed downstream
+ * is a candidate for pullExecution. Without it, the node may never execute.
+ */
+export const pullCandidateRule = {
+    name: 'DESIGN_PULL_CANDIDATE',
+    validate(ast) {
+        const errors = [];
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            if (!nt)
+                continue;
+            // Skip if already has pullExecution configured
+            if (instance.config?.pullExecution || nt.defaultConfig?.pullExecution)
+                continue;
+            // Skip expression nodes (they are already pull-executed by nature)
+            if (nt.expression)
+                continue;
+            // Check for incoming step connections
+            const incomingStep = getIncoming(ast, instance.id).filter((c) => {
+                const portDef = nt.inputs[c.to.port];
+                return isStepPort(c.to.port, portDef);
+            });
+            if (incomingStep.length > 0)
+                continue; // Has step trigger, not a candidate
+            // Check if any data outputs are consumed downstream
+            const dataOutputs = Object.keys(nt.outputs).filter((p) => !STEP_PORTS.has(p));
+            const hasConsumedOutput = dataOutputs.some((port) => getOutgoing(ast, instance.id, port).length > 0);
+            if (hasConsumedOutput) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_PULL_CANDIDATE',
+                    message: `Node '${instance.id}' has no incoming step connection but its data outputs are consumed downstream. Consider adding [pullExecution: execute] so it executes on demand.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Rule 7: Unused Pull Execution
+// ---------------------------------------------------------------------------
+/**
+ * A node marked with pullExecution but no downstream node reads its data output.
+ * The node will never execute since pull execution requires a consumer.
+ */
+export const pullUnusedRule = {
+    name: 'DESIGN_PULL_UNUSED',
+    validate(ast) {
+        const errors = [];
+        for (const instance of ast.instances) {
+            const nt = resolveNodeType(ast, instance);
+            if (!nt)
+                continue;
+            const isPull = instance.config?.pullExecution || nt.defaultConfig?.pullExecution;
+            if (!isPull)
+                continue;
+            // Check if any data output ports are connected
+            const dataOutputs = Object.keys(nt.outputs).filter((p) => !STEP_PORTS.has(p));
+            const hasConnectedOutput = dataOutputs.some((port) => getOutgoing(ast, instance.id, port).length > 0);
+            if (!hasConnectedOutput) {
+                errors.push({
+                    type: 'warning',
+                    code: 'DESIGN_PULL_UNUSED',
+                    message: `Node '${instance.id}' is marked with pullExecution but no downstream node reads its data output. It will never execute.`,
+                    node: instance.id,
+                });
+            }
+        }
+        return errors;
+    },
+};
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export const designValidationRules = [
+    asyncNoErrorPathRule,
+    scopeNoFailureExitRule,
+    unboundedRetryRule,
+    fanoutNoFaninRule,
+    exitDataUnreachableRule,
+    pullCandidateRule,
+    pullUnusedRule,
+];
+export function getDesignValidationRules() {
+    return designValidationRules;
+}
+//# sourceMappingURL=design-rules.js.map