@synergenius/flow-weaver 0.2.1 → 0.4.0

package/dist/docs/index.js

@@ -0,0 +1,256 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// ---------------------------------------------------------------------------
+// Internals
+// ---------------------------------------------------------------------------
+function getDocsDir() {
+    // Resolve docs/reference relative to the package root.
+    // In development: src/docs/index.ts -> ../../docs/reference
+    // In dist: dist/docs/index.js -> ../../docs/reference
+    const thisFile = fileURLToPath(import.meta.url);
+    const packageRoot = path.resolve(path.dirname(thisFile), '..', '..');
+    return path.join(packageRoot, 'docs', 'reference');
+}
+function parseFrontmatter(raw) {
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch) {
+        return {
+            frontmatter: { name: '', description: '', keywords: [] },
+            body: raw,
+        };
+    }
+    const fmBlock = fmMatch[1];
+    const body = fmMatch[2];
+    let name = '';
+    let description = '';
+    let keywords = [];
+    for (const line of fmBlock.split('\n')) {
+        const nameMatch = line.match(/^name:\s*(.+)$/);
+        if (nameMatch) {
+            name = nameMatch[1].trim();
+            continue;
+        }
+        const descMatch = line.match(/^description:\s*(.+)$/);
+        if (descMatch) {
+            description = descMatch[1].trim();
+            continue;
+        }
+        const kwMatch = line.match(/^keywords:\s*\[(.+)\]$/);
+        if (kwMatch) {
+            keywords = kwMatch[1].split(',').map((k) => k.trim().replace(/^['"]|['"]$/g, ''));
+            continue;
+        }
+    }
+    return { frontmatter: { name, description, keywords }, body };
+}
+function splitSections(body) {
+    const lines = body.split('\n');
+    const sections = [];
+    let currentHeading = '';
+    let currentLevel = 0;
+    let currentLines = [];
+    function flush() {
+        if (currentHeading || currentLines.length > 0) {
+            const content = currentLines.join('\n').trim();
+            const codeBlocks = [];
+            const codeRe = /```[\s\S]*?```/g;
+            let m;
+            while ((m = codeRe.exec(content)) !== null) {
+                codeBlocks.push(m[0]);
+            }
+            sections.push({
+                heading: currentHeading,
+                level: currentLevel,
+                content,
+                codeBlocks,
+            });
+        }
+    }
+    for (const line of lines) {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            flush();
+            currentLevel = headingMatch[1].length;
+            currentHeading = headingMatch[2];
+            currentLines = [];
+        }
+        else {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * List all available documentation topics.
+ */
+export function listTopics() {
+    const docsDir = getDocsDir();
+    if (!fs.existsSync(docsDir))
+        return [];
+    const files = fs.readdirSync(docsDir).filter((f) => f.endsWith('.md')).sort();
+    return files.map((file) => {
+        const raw = fs.readFileSync(path.join(docsDir, file), 'utf-8');
+        const { frontmatter } = parseFrontmatter(raw);
+        return {
+            slug: file.replace(/\.md$/, ''),
+            name: frontmatter.name,
+            description: frontmatter.description,
+            keywords: frontmatter.keywords,
+        };
+    });
+}
+/**
+ * Read a single documentation topic.
+ * @param slug - Topic slug (filename without .md)
+ * @param compact - If true, return a compact LLM-friendly version
+ */
+export function readTopic(slug, compact) {
+    const docsDir = getDocsDir();
+    const filePath = path.join(docsDir, `${slug}.md`);
+    if (!fs.existsSync(filePath))
+        return null;
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const content = compact ? buildCompactContent(frontmatter, body) : body.trim();
+    return {
+        slug,
+        name: frontmatter.name,
+        description: frontmatter.description,
+        keywords: frontmatter.keywords,
+        content,
+    };
+}
+/**
+ * Read a topic and return structured sections (for JSON output).
+ */
+export function readTopicStructured(slug) {
+    const docsDir = getDocsDir();
+    const filePath = path.join(docsDir, `${slug}.md`);
+    if (!fs.existsSync(filePath))
+        return null;
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const { frontmatter, body } = parseFrontmatter(raw);
+    const sections = splitSections(body);
+    return {
+        slug,
+        name: frontmatter.name,
+        description: frontmatter.description,
+        keywords: frontmatter.keywords,
+        sections,
+    };
+}
+/**
+ * Search across all documentation topics.
+ * Returns matching sections with context.
+ */
+export function searchDocs(query) {
+    const topics = listTopics();
+    const docsDir = getDocsDir();
+    const queryLower = query.toLowerCase();
+    const queryTerms = queryLower.split(/\s+/).filter(Boolean);
+    const results = [];
+    for (const topic of topics) {
+        // Check keywords match
+        const keywordMatch = topic.keywords.some((kw) => queryTerms.some((term) => kw.toLowerCase().includes(term)));
+        const filePath = path.join(docsDir, `${topic.slug}.md`);
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const { body } = parseFrontmatter(raw);
+        const sections = splitSections(body);
+        for (const section of sections) {
+            const sectionLower = section.content.toLowerCase();
+            const headingLower = section.heading.toLowerCase();
+            // Calculate relevance
+            let relevance = 0;
+            // Exact phrase match in content
+            if (sectionLower.includes(queryLower)) {
+                relevance += 10;
+            }
+            // Individual term matches
+            for (const term of queryTerms) {
+                if (headingLower.includes(term))
+                    relevance += 5;
+                if (sectionLower.includes(term))
+                    relevance += 2;
+            }
+            // Keyword bonus
+            if (keywordMatch)
+                relevance += 3;
+            if (relevance > 0) {
+                // Build excerpt: find matching lines
+                const lines = section.content.split('\n');
+                const matchingLines = [];
+                for (const line of lines) {
+                    if (queryTerms.some((term) => line.toLowerCase().includes(term))) {
+                        matchingLines.push(line.trim());
+                        if (matchingLines.length >= 3)
+                            break;
+                    }
+                }
+                results.push({
+                    topic: topic.name,
+                    slug: topic.slug,
+                    section: section.heading,
+                    heading: section.heading,
+                    excerpt: matchingLines.join('\n') || section.content.slice(0, 200),
+                    relevance,
+                });
+            }
+        }
+    }
+    // Sort by relevance descending
+    results.sort((a, b) => b.relevance - a.relevance);
+    return results;
+}
+// ---------------------------------------------------------------------------
+// Compact mode builder
+// ---------------------------------------------------------------------------
+function buildCompactContent(frontmatter, body) {
+    const lines = body.split('\n');
+    const output = [];
+    // Header
+    output.push(`# ${frontmatter.name}`);
+    output.push(frontmatter.description);
+    output.push('');
+    let inCodeBlock = false;
+    let inTable = false;
+    for (const line of lines) {
+        // Track code blocks - always include them
+        if (line.trimStart().startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            output.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            output.push(line);
+            continue;
+        }
+        // Include headings
+        if (line.match(/^#{1,6}\s/)) {
+            output.push('');
+            output.push(line);
+            continue;
+        }
+        // Include table content
+        if (line.trim().startsWith('|')) {
+            inTable = true;
+            output.push(line);
+            continue;
+        }
+        if (inTable && !line.trim().startsWith('|')) {
+            inTable = false;
+        }
+        // Skip prose paragraphs (non-empty lines that aren't headings, code, or tables)
+        // But keep list items and blockquotes
+        if (line.trim().startsWith('- ') || line.trim().startsWith('* ') || line.trim().startsWith('> ')) {
+            output.push(line);
+            continue;
+        }
+    }
+    return output.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+//# sourceMappingURL=index.js.map

package/dist/generator/control-flow.d.ts

@@ -50,5 +50,18 @@ export declare function detectBranchingChains(branchingNodes: Set<string>, branc
     successNodes: Set<string>;
     failureNodes: Set<string>;
 }>): Map<string, string[]>;
+/**
+ * Compute parallel levels from a control flow graph.
+ *
+ * Uses a modified Kahn's algorithm that tracks the "wave" (level) each node
+ * belongs to. Nodes at the same level with no direct data edges between them
+ * can execute in parallel.
+ *
+ * @param cfg - Control flow graph with nodes and edges
+ * @param branchingNodes - Set of branching node IDs to exclude from parallel groups
+ * @param scopedChildren - Set of per-port scoped child IDs to exclude from parallel groups
+ * @returns Array of groups — each inner array contains node IDs that can run in parallel
+ */
+export declare function computeParallelLevels(cfg: ControlFlowGraph, branchingNodes: Set<string>, scopedChildren: Set<string>): string[][];
 export declare function determineExecutionOrder(workflow: TWorkflowAST, nodes: TNodeTypeAST[]): string[];
 //# sourceMappingURL=control-flow.d.ts.map

package/dist/generator/control-flow.js

@@ -257,6 +257,80 @@ export function detectBranchingChains(branchingNodes, branchRegions) {
     }
     return chains;
 }
+/**
+ * Compute parallel levels from a control flow graph.
+ *
+ * Uses a modified Kahn's algorithm that tracks the "wave" (level) each node
+ * belongs to. Nodes at the same level with no direct data edges between them
+ * can execute in parallel.
+ *
+ * @param cfg - Control flow graph with nodes and edges
+ * @param branchingNodes - Set of branching node IDs to exclude from parallel groups
+ * @param scopedChildren - Set of per-port scoped child IDs to exclude from parallel groups
+ * @returns Array of groups — each inner array contains node IDs that can run in parallel
+ */
+export function computeParallelLevels(cfg, branchingNodes, scopedChildren) {
+    const inDegree = new Map(cfg.inDegree);
+    const queue = [];
+    const nodeLevel = new Map();
+    // Start with nodes at in-degree 0
+    inDegree.forEach((degree, node) => {
+        if (degree === 0) {
+            queue.push(node);
+            nodeLevel.set(node, 0);
+        }
+    });
+    // BFS assigning levels
+    while (queue.length > 0) {
+        const node = queue.shift();
+        const level = nodeLevel.get(node);
+        const successors = cfg.graph.get(node) || [];
+        for (const succ of successors) {
+            const newDeg = (inDegree.get(succ) || 0) - 1;
+            inDegree.set(succ, newDeg);
+            // Successor's level = max of all predecessor levels + 1
+            const currentLevel = nodeLevel.get(succ) ?? 0;
+            nodeLevel.set(succ, Math.max(currentLevel, level + 1));
+            if (newDeg === 0) {
+                queue.push(succ);
+            }
+        }
+    }
+    // Group nodes by level
+    const levelGroups = new Map();
+    nodeLevel.forEach((level, node) => {
+        if (isStartNode(node) || isExitNode(node))
+            return;
+        if (!levelGroups.has(level)) {
+            levelGroups.set(level, []);
+        }
+        levelGroups.get(level).push(node);
+    });
+    // Sort levels and split groups: branching/scoped nodes become their own single-node groups
+    const sortedLevels = Array.from(levelGroups.keys()).sort((a, b) => a - b);
+    const result = [];
+    for (const level of sortedLevels) {
+        const nodes = levelGroups.get(level);
+        const parallelGroup = [];
+        for (const node of nodes) {
+            if (branchingNodes.has(node) || scopedChildren.has(node)) {
+                // Branching and scoped nodes must run sequentially
+                if (parallelGroup.length > 0) {
+                    result.push([...parallelGroup]);
+                    parallelGroup.length = 0;
+                }
+                result.push([node]);
+            }
+            else {
+                parallelGroup.push(node);
+            }
+        }
+        if (parallelGroup.length > 0) {
+            result.push(parallelGroup);
+        }
+    }
+    return result;
+}
 export function determineExecutionOrder(workflow, nodes) {
     const nodeMap = new Map();
     nodes.forEach((node) => nodeMap.set(node.functionName, node));

package/dist/generator/inngest.js

@@ -24,6 +24,7 @@ const BUILTIN_IMPORT_PREFIX = '@synergenius/flow-weaver/built-in-nodes';
 const BUILT_IN_HANDLERS = {
     delay: 'delay',
     waitForEvent: 'waitForEvent',
+    waitForAgent: 'waitForAgent',
     invokeWorkflow: 'invokeWorkflow',
 };
 /**
@@ -54,6 +55,8 @@ function verifyBuiltInSignature(nodeType) {
             return inputNames.includes('eventName');
         case 'invokeWorkflow':
             return inputNames.includes('functionId') && inputNames.includes('payload');
+        case 'waitForAgent':
+            return inputNames.includes('agentId') && inputNames.includes('context');
         default:
             return false;
     }
@@ -354,6 +357,21 @@ function emitNodeCall(nodeId, nodeType, workflow, nodeTypes, indent, lines) {
         lines.push('');
         return;
     }
+    if (builtIn === 'waitForAgent') {
+        const safeId = toValidIdentifier(nodeId);
+        const args = buildNodeArgs(nodeId, nodeType, workflow, nodeTypes);
+        const agentIdArg = args[1]; // execute=args[0], agentId=args[1]
+        // Map waitForAgent to step.waitForEvent with agent-scoped event name
+        lines.push(`${indent}const ${safeId}_raw = await step.waitForEvent('${nodeId}', {`);
+        lines.push(`${indent}  event: \`agent/\${${agentIdArg}}\`,`);
+        lines.push(`${indent}  timeout: '7d',`);
+        lines.push(`${indent}});`);
+        lines.push(`${indent}${safeId}_result = ${safeId}_raw`);
+        lines.push(`${indent}  ? { onSuccess: true, onFailure: false, agentResult: ${safeId}_raw.data ?? {} }`);
+        lines.push(`${indent}  : { onSuccess: false, onFailure: true, agentResult: {} };`);
+        lines.push('');
+        return;
+    }
     if (builtIn === 'invokeWorkflow') {
         const safeId = toValidIdentifier(nodeId);
         const args = buildNodeArgs(nodeId, nodeType, workflow, nodeTypes);
@@ -502,6 +520,11 @@ function emitPromiseAll(nodeIds, workflow, nodeTypes, indent, lines, generatedNo
             waitCall += ` })`;
             stepCalls.push(waitCall);
         }
+        else if (builtIn === 'waitForAgent') {
+            const args = buildNodeArgs(nodeId, nt, workflow, nodeTypes);
+            const agentIdArg = args[1];
+            stepCalls.push(`${indent}  step.waitForEvent('${nodeId}', { event: \`agent/\${${agentIdArg}}\`, timeout: '7d' })`);
+        }
         else if (builtIn === 'invokeWorkflow') {
             const args = buildNodeArgs(nodeId, nt, workflow, nodeTypes);
             const functionIdArg = args[1];

package/dist/generator/unified.js

@@ -1,7 +1,7 @@
 import { extractStartPorts } from '../ast/workflow-utils.js';
 import { mapToTypeScript } from '../type-mappings.js';
 import { buildNodeArgumentsWithContext, toValidIdentifier } from './code-utils.js';
-import { buildControlFlowGraph, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, } from './control-flow.js';
+import { buildControlFlowGraph, computeParallelLevels, detectBranchingChains, findAllBranchingNodes, findNodesInBranch, performKahnsTopologicalSort, isPerPortScopedChild, } from './control-flow.js';
 import { RESERVED_NODE_NAMES, RESERVED_PORT_NAMES, EXECUTION_STRATEGIES, isStartNode, isExitNode, isExecutePort, isSuccessPort, isFailurePort, } from '../constants.js';
 /**
  * Helper: Determine if an instance has pull execution enabled
@@ -246,6 +246,59 @@ export function generateControlFlowWithExecutionContext(workflow, nodeTypes, isA
             chainMembers.add(chain[i]);
         }
     });
+    // Compute parallel levels for async workflows
+    const perPortScopedChildrenSet = new Set();
+    workflow.instances.forEach((instance) => {
+        if (isPerPortScopedChild(instance, workflow, nodeTypes)) {
+            perPortScopedChildrenSet.add(instance.id);
+        }
+    });
+    const parallelGroupOf = new Map();
+    if (isAsync) {
+        const parallelLevels = computeParallelLevels(cfg, branchingNodes, perPortScopedChildrenSet);
+        for (const group of parallelLevels) {
+            if (group.length < 2)
+                continue;
+            // Filter out nodes that can't be parallelized
+            const eligible = group.filter((id) => {
+                if (nodesInBranches.has(id))
+                    return false;
+                if (pullExecutionNodes.has(id))
+                    return false;
+                if (nodeLevelScopedChildren.has(id))
+                    return false;
+                if (nodesPromotedFromBranches.has(id))
+                    return false;
+                if (chainMembers.has(id))
+                    return false;
+                if (branchingNodes.has(id))
+                    return false;
+                return true;
+            });
+            if (eligible.length >= 2) {
+                for (const nodeId of eligible) {
+                    parallelGroupOf.set(nodeId, eligible);
+                }
+            }
+        }
+    }
+    // Pre-declare execution indices for parallel group nodes
+    if (parallelGroupOf.size > 0) {
+        const declared = new Set();
+        parallelGroupOf.forEach((_, instanceId) => {
+            if (declared.has(instanceId))
+                return;
+            declared.add(instanceId);
+            // Only declare if not already declared by earlier let declarations
+            if (!nodesInBranches.has(instanceId) &&
+                !branchingNodes.has(instanceId) &&
+                !pullExecutionNodes.has(instanceId) &&
+                !nodeLevelScopedChildren.has(instanceId)) {
+                lines.push(`  let ${toValidIdentifier(instanceId)}Idx: number | undefined;`);
+            }
+        });
+        lines.push('');
+    }
     const generatedNodes = new Set();
     const availableVars = new Map();
     Object.keys(extractStartPorts(workflow)).forEach((portName) => {
@@ -272,6 +325,26 @@ export function generateControlFlowWithExecutionContext(workflow, nodeTypes, isA
             lines.push(`  // Node '${instance.id}' skipped: type '${instance.nodeType}' not found`);
             return;
         }
+        // Handle parallel groups: emit Promise.all when hitting first node of a group
+        if (parallelGroupOf.has(instanceId)) {
+            const group = parallelGroupOf.get(instanceId);
+            const ungeneratedGroup = group.filter((id) => !generatedNodes.has(id));
+            if (ungeneratedGroup.length >= 2) {
+                generateParallelGroupWithContext(ungeneratedGroup, workflow, nodeTypes, availableVars, lines, generatedNodes, '  ', isAsync, 'ctx', bundleMode, branchingNodes);
+                // Generate scoped children for each parallel node
+                for (const parallelNodeId of ungeneratedGroup) {
+                    const inst = workflow.instances.find((i) => i.id === parallelNodeId);
+                    if (!inst)
+                        continue;
+                    const nt = nodeTypes.find((n) => n.name === inst.nodeType || n.functionName === inst.nodeType);
+                    if (!nt)
+                        continue;
+                    generateScopedChildrenExecution(inst, nt, workflow, nodeTypes, generatedNodes, availableVars, lines, '  ', branchingNodes, branchRegions, isAsync, bundleMode);
+                }
+                return;
+            }
+            // else: degenerated to 1 or 0, fall through to sequential handling
+        }
         if (branchingNodes.has(instanceId)) {
             // Chain members are generated by their chain head — skip
             if (chainMembers.has(instanceId)) {
@@ -342,7 +415,8 @@ export function generateControlFlowWithExecutionContext(workflow, nodeTypes, isA
                 const nodeUseConst = !nodesInBranches.has(instanceId) &&
                     !branchingNodes.has(instanceId) &&
                     !pullExecutionNodes.has(instanceId) &&
-                    !nodeLevelScopedChildren.has(instanceId);
+                    !nodeLevelScopedChildren.has(instanceId) &&
+                    !parallelGroupOf.has(instanceId);
                 generateNodeCallWithContext(instance, nodeType, workflow, availableVars, lines, nodeTypes, '  ', isAsync, nodeUseConst, undefined, // instanceParent
                 'ctx', // ctxVar
                 bundleMode, false, // skipExecuteGuard
@@ -566,6 +640,52 @@ function generateScopedChildrenExecution(parentInstance, parentNodeType, workflo
     lines.push(`${indent}ctx.mergeScope(${parentInstance.id}_scopedCtx);`);
     lines.push(``);
 }
+/**
+ * Generate a Promise.all block for 2+ parallel nodes in the unified generator.
+ *
+ * Each node's execution code is wrapped in an async IIFE inside Promise.all.
+ * The outer `let` variables for execution indices are assigned inside the IIFEs.
+ */
+function generateParallelGroupWithContext(nodeIds, workflow, nodeTypes, availableVars, lines, generatedNodes, indent, isAsync, ctxVar, bundleMode, branchingNodes) {
+    // Collect code buffers for each node
+    const nodeBuffers = [];
+    for (const nodeId of nodeIds) {
+        const instance = workflow.instances.find((i) => i.id === nodeId);
+        if (!instance)
+            continue;
+        const nodeType = nodeTypes.find((nt) => nt.name === instance.nodeType || nt.functionName === instance.nodeType);
+        if (!nodeType)
+            continue;
+        const nodeLines = [];
+        generateNodeCallWithContext(instance, nodeType, workflow, availableVars, nodeLines, nodeTypes, `${indent}    `, // indent for inside the async IIFE
+        isAsync, false, // useConst = false — outer let declarations
+        undefined, ctxVar, bundleMode, false, branchingNodes);
+        nodeBuffers.push({ id: nodeId, lines: nodeLines });
+    }
+    // Fallback: if only 0-1 nodes remain, emit directly without Promise.all
+    if (nodeBuffers.length < 2) {
+        for (const buf of nodeBuffers) {
+            for (const line of buf.lines) {
+                lines.push(line);
+            }
+            generatedNodes.add(buf.id);
+        }
+        return;
+    }
+    lines.push(`${indent}await Promise.all([`);
+    for (let i = 0; i < nodeBuffers.length; i++) {
+        const buf = nodeBuffers[i];
+        const comma = i < nodeBuffers.length - 1 ? ',' : '';
+        lines.push(`${indent}  (async () => {`);
+        for (const line of buf.lines) {
+            lines.push(line);
+        }
+        lines.push(`${indent}  })()${comma}`);
+        generatedNodes.add(buf.id);
+    }
+    lines.push(`${indent}]);`);
+    lines.push('');
+}
 /**
  * Sort branch nodes topologically based on their dependencies
  *

package/dist/jsdoc-parser.d.ts

@@ -135,6 +135,28 @@ export interface JSDocWorkflowConfig {
             route?: 'ok' | 'fail';
         }>;
     }>;
+    /** @fanOut macros that expand to 1-to-N connections */
+    fanOuts?: Array<{
+        source: {
+            node: string;
+            port: string;
+        };
+        targets: Array<{
+            node: string;
+            port?: string;
+        }>;
+    }>;
+    /** @fanIn macros that expand to N-to-1 connections */
+    fanIns?: Array<{
+        sources: Array<{
+            node: string;
+            port?: string;
+        }>;
+        target: {
+            node: string;
+            port: string;
+        };
+    }>;
     /** @trigger annotation — event name and/or cron schedule */
     trigger?: {
         event?: string;
@@ -287,6 +309,8 @@ export declare class JSDocParser {
      * Format: @path Start -> validator:ok -> classifier -> urgencyRouter:fail -> escalate -> Exit
      */
     private parsePathTag;
+    private parseFanOutTag;
+    private parseFanInTag;
     /**
      * Parse @trigger tag using Chevrotain parser.
      */

package/dist/jsdoc-parser.js

@@ -5,7 +5,7 @@
  */
 import { isExecutePort, isSuccessPort, isFailurePort, isScopedMandatoryPort } from './constants.js';
 import { inferDataTypeFromTS } from './type-mappings.js';
-import { parsePortLine, parseNodeLine, parseConnectLine, parsePositionLine, parseScopeLine, parseMapLine, parsePathLine, parseTriggerLine, parseCancelOnLine, parseThrottleLine, } from './chevrotain-parser/index.js';
+import { parsePortLine, parseNodeLine, parseConnectLine, parsePositionLine, parseScopeLine, parseMapLine, parsePathLine, parseFanOutLine, parseFanInLine, parseTriggerLine, parseCancelOnLine, parseThrottleLine, } from './chevrotain-parser/index.js';
 /**
  * Extract the type of a field from a callback's return type using ts-morph Type API.
  *
@@ -260,6 +260,12 @@ export class JSDocParser {
                 case 'path':
                     this.parsePathTag(tag, config, warnings);
                     break;
+                case 'fanOut':
+                    this.parseFanOutTag(tag, config, warnings);
+                    break;
+                case 'fanIn':
+                    this.parseFanInTag(tag, config, warnings);
+                    break;
                 case 'trigger':
                     this.parseTriggerTag(tag, config, warnings);
                     break;
@@ -864,6 +870,40 @@ export class JSDocParser {
             steps: result.steps,
         });
     }
+    parseFanOutTag(tag, config, warnings) {
+        const comment = tag.getCommentText() || '';
+        const result = parseFanOutLine(`@fanOut ${comment}`, warnings);
+        if (!result) {
+            warnings.push(`Invalid @fanOut tag format: ${comment}`);
+            return;
+        }
+        if (!result.source.port) {
+            warnings.push(`@fanOut source must specify a port: ${comment}`);
+            return;
+        }
+        config.fanOuts = config.fanOuts || [];
+        config.fanOuts.push({
+            source: { node: result.source.node, port: result.source.port },
+            targets: result.targets,
+        });
+    }
+    parseFanInTag(tag, config, warnings) {
+        const comment = tag.getCommentText() || '';
+        const result = parseFanInLine(`@fanIn ${comment}`, warnings);
+        if (!result) {
+            warnings.push(`Invalid @fanIn tag format: ${comment}`);
+            return;
+        }
+        if (!result.target.port) {
+            warnings.push(`@fanIn target must specify a port: ${comment}`);
+            return;
+        }
+        config.fanIns = config.fanIns || [];
+        config.fanIns.push({
+            sources: result.sources,
+            target: { node: result.target.node, port: result.target.port },
+        });
+    }
     /**
      * Parse @trigger tag using Chevrotain parser.
      */