@synergenius/flow-weaver 0.3.0 → 0.4.0

package/README.md

@@ -1,5 +1,6 @@
 # @synergenius/flow-weaver
 
+[![npm version](https://img.shields.io/npm/v/@synergenius/flow-weaver.svg)](https://www.npmjs.com/package/@synergenius/flow-weaver)
 [![License: ELv2-based](https://img.shields.io/badge/License-ELv2--based-blue.svg)](./LICENSE)
 [![Node.js](https://img.shields.io/badge/Node.js-%3E%3D18-green.svg)](https://nodejs.org)
 

package/dist/annotation-generator.js

@@ -247,6 +247,16 @@ export class AnnotationGenerator {
                     const stepsStr = macro.steps.map(s => s.route ? `${s.node}:${s.route}` : s.node).join(' -> ');
                     lines.push(` * @path ${stepsStr}`);
                 }
+                else if (macro.type === 'fanOut') {
+                    const src = `${macro.source.node}.${macro.source.port}`;
+                    const tgts = macro.targets.map(t => t.port ? `${t.node}.${t.port}` : t.node).join(', ');
+                    lines.push(` * @fanOut ${src} -> ${tgts}`);
+                }
+                else if (macro.type === 'fanIn') {
+                    const srcs = macro.sources.map(s => s.port ? `${s.node}.${s.port}` : s.node).join(', ');
+                    const tgt = `${macro.target.node}.${macro.target.port}`;
+                    lines.push(` * @fanIn ${srcs} -> ${tgt}`);
+                }
             }
         }
         // Add node positions (if they exist)
@@ -456,6 +466,32 @@ function isConnectionCoveredByMacroStatic(conn, macros) {
                 return true;
             }
         }
+        else if (macro.type === 'fanOut') {
+            if (conn.from.scope || conn.to.scope)
+                continue;
+            // Check if connection matches the fan-out pattern
+            if (conn.from.node === macro.source.node && conn.from.port === macro.source.port) {
+                for (const target of macro.targets) {
+                    const targetPort = target.port ?? macro.source.port;
+                    if (conn.to.node === target.node && conn.to.port === targetPort) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else if (macro.type === 'fanIn') {
+            if (conn.from.scope || conn.to.scope)
+                continue;
+            // Check if connection matches the fan-in pattern
+            if (conn.to.node === macro.target.node && conn.to.port === macro.target.port) {
+                for (const source of macro.sources) {
+                    const sourcePort = source.port ?? macro.target.port;
+                    if (conn.from.node === source.node && conn.from.port === sourcePort) {
+                        return true;
+                    }
+                }
+            }
+        }
     }
     return false;
 }

package/dist/api/generate-in-place.js

@@ -155,6 +155,11 @@ function generateRuntimeSection(functionName, production, moduleFormat = 'esm',
         lines.push(`import { GeneratedExecutionContext, CancellationError } from '${externalRuntimePath}';`);
         if (!production) {
             lines.push(`import type { TDebugger } from '${externalRuntimePath}';`);
+            // Declare __flowWeaverDebugger__ so body code can reference it
+            lines.push('declare const __flowWeaverDebugger__: TDebugger | undefined;');
+            // Include inline debug client (createFlowWeaverDebugClient is not exported from runtime)
+            lines.push('');
+            lines.push(generateInlineDebugClient(moduleFormat));
         }
     }
     else {
@@ -990,6 +995,30 @@ function isConnectionCoveredByMacro(conn, macros) {
                 return true;
             }
         }
+        else if (macro.type === 'fanOut') {
+            if (conn.from.scope || conn.to.scope)
+                continue;
+            if (conn.from.node === macro.source.node && conn.from.port === macro.source.port) {
+                for (const target of macro.targets) {
+                    const targetPort = target.port ?? macro.source.port;
+                    if (conn.to.node === target.node && conn.to.port === targetPort) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else if (macro.type === 'fanIn') {
+            if (conn.from.scope || conn.to.scope)
+                continue;
+            if (conn.to.node === macro.target.node && conn.to.port === macro.target.port) {
+                for (const source of macro.sources) {
+                    const sourcePort = source.port ?? macro.target.port;
+                    if (conn.from.node === source.node && conn.from.port === sourcePort) {
+                        return true;
+                    }
+                }
+            }
+        }
     }
     return false;
 }
@@ -1124,6 +1153,16 @@ function generateWorkflowJSDoc(ast, options = {}) {
                 const stepsStr = macro.steps.map(s => s.route ? `${s.node}:${s.route}` : s.node).join(' -> ');
                 lines.push(` * @path ${stepsStr}`);
             }
+            else if (macro.type === 'fanOut') {
+                const src = `${macro.source.node}.${macro.source.port}`;
+                const tgts = macro.targets.map(t => t.port ? `${t.node}.${t.port}` : t.node).join(', ');
+                lines.push(` * @fanOut ${src} -> ${tgts}`);
+            }
+            else if (macro.type === 'fanIn') {
+                const srcs = macro.sources.map(s => s.port ? `${s.node}.${s.port}` : s.node).join(', ');
+                const tgt = `${macro.target.node}.${macro.target.port}`;
+                lines.push(` * @fanIn ${srcs} -> ${tgt}`);
+            }
         }
     }
     // Auto-position: compute default positions for nodes without explicit positions.

package/dist/api/generate.js

@@ -88,8 +88,18 @@ export function generateCode(ast, options) {
         lines.push(generateImportStatement(['GeneratedExecutionContext', 'CancellationError'], externalRuntimePath, moduleFormat));
         addLine();
         if (!production) {
-            lines.push(generateImportStatement(['TDebugger', 'createFlowWeaverDebugClient'], externalRuntimePath, moduleFormat));
+            // Import TDebugger type from external runtime
+            lines.push(moduleFormat === 'cjs'
+                ? `const { TDebugger } = require('${externalRuntimePath}');`
+                : `import type { TDebugger } from '${externalRuntimePath}';`);
             addLine();
+            // Include inline debug client (createFlowWeaverDebugClient is not exported from runtime)
+            const inlineDebugClient = generateInlineDebugClient(moduleFormat);
+            const debugClientLines = inlineDebugClient.split('\n');
+            debugClientLines.forEach((line) => {
+                lines.push(line);
+                addLine();
+            });
         }
         lines.push('');
         addLine();

package/dist/api/manipulation/nodes.js

@@ -77,6 +77,12 @@ export function removeNode(ast, nodeId, options = {}) {
                 if (macro.type === 'path') {
                     return !macro.steps.some(s => s.node === nodeId);
                 }
+                if (macro.type === 'fanOut') {
+                    return macro.source.node !== nodeId && !macro.targets.some(t => t.node === nodeId);
+                }
+                if (macro.type === 'fanIn') {
+                    return macro.target.node !== nodeId && !macro.sources.some(s => s.node === nodeId);
+                }
                 return true;
             });
             if (draft.macros.length === 0) {
@@ -134,6 +140,22 @@ export function renameNode(ast, oldId, newId) {
                 else if (macro.type === 'path') {
                     macro.steps = macro.steps.map(s => s.node === oldId ? { ...s, node: newId } : s);
                 }
+                else if (macro.type === 'fanOut') {
+                    if (macro.source.node === oldId)
+                        macro.source.node = newId;
+                    for (const t of macro.targets) {
+                        if (t.node === oldId)
+                            t.node = newId;
+                    }
+                }
+                else if (macro.type === 'fanIn') {
+                    if (macro.target.node === oldId)
+                        macro.target.node = newId;
+                    for (const s of macro.sources) {
+                        if (s.node === oldId)
+                            s.node = newId;
+                    }
+                }
             }
         }
     });

package/dist/ast/types.d.ts

@@ -111,7 +111,7 @@ export type TWorkflowAST = {
  * A sugar macro that expands to a full scope pattern or connection set.
  * Stored on the workflow AST for round-trip preservation in generateInPlace.
  */
-export type TWorkflowMacro = TMapMacro | TPathMacro;
+export type TWorkflowMacro = TMapMacro | TPathMacro | TFanOutMacro | TFanInMacro;
 export type TMapMacro = {
     type: 'map';
     /** Instance ID for the synthetic iterator node (e.g., "loop") */
@@ -133,6 +133,32 @@ export type TPathMacro = {
         route?: 'ok' | 'fail';
     }>;
 };
+export type TFanOutMacro = {
+    type: 'fanOut';
+    /** Single source port that fans out to multiple targets */
+    source: {
+        node: string;
+        port: string;
+    };
+    /** Target nodes/ports receiving the fanned-out data */
+    targets: Array<{
+        node: string;
+        port?: string;
+    }>;
+};
+export type TFanInMacro = {
+    type: 'fanIn';
+    /** Source nodes/ports that fan in to a single target */
+    sources: Array<{
+        node: string;
+        port?: string;
+    }>;
+    /** Single target port receiving all the fanned-in data */
+    target: {
+        node: string;
+        port: string;
+    };
+};
 /**
  * Default configuration for a node type that can be overridden per instance.
  */

package/dist/built-in-nodes/index.d.ts

@@ -1,5 +1,6 @@
 export { delay } from './delay.js';
 export { waitForEvent } from './wait-for-event.js';
+export { waitForAgent } from './wait-for-agent.js';
 export { invokeWorkflow } from './invoke-workflow.js';
 export type { FwMockConfig } from './mock-types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/built-in-nodes/index.js

@@ -1,4 +1,5 @@
 export { delay } from './delay.js';
 export { waitForEvent } from './wait-for-event.js';
+export { waitForAgent } from './wait-for-agent.js';
 export { invokeWorkflow } from './invoke-workflow.js';
 //# sourceMappingURL=index.js.map

package/dist/built-in-nodes/invoke-workflow.js

@@ -19,7 +19,18 @@ export async function invokeWorkflow(execute, functionId, payload, timeout) {
         // No mock data for this functionId — simulate failure
         return { onSuccess: false, onFailure: true, result: {} };
     }
-    // No mocks: original no-op behavior (always succeeds)
+    // Check local workflow registry (populated by executeWorkflowFromFile)
+    const registry = globalThis.__fw_workflow_registry__;
+    if (registry?.[functionId]) {
+        try {
+            const result = await registry[functionId](true, payload);
+            return { onSuccess: true, onFailure: false, result: result ?? {} };
+        }
+        catch {
+            return { onSuccess: false, onFailure: true, result: {} };
+        }
+    }
+    // No mocks, no registry match: original no-op behavior (always succeeds)
     return { onSuccess: true, onFailure: false, result: {} };
 }
 //# sourceMappingURL=invoke-workflow.js.map

package/dist/built-in-nodes/mock-types.d.ts

@@ -8,6 +8,8 @@ export interface FwMockConfig {
     events?: Record<string, object>;
     /** Mock invocation results keyed by functionId. Used by invokeWorkflow. */
     invocations?: Record<string, object>;
+    /** Mock agent results keyed by agentId. Used by waitForAgent. */
+    agents?: Record<string, object>;
     /** When true, delay nodes skip the real sleep (1ms instead of full duration). */
     fast?: boolean;
 }

package/dist/built-in-nodes/wait-for-agent.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @flowWeaver nodeType
+ * @input agentId - Agent/task identifier
+ * @input context - Context data to send to the agent
+ * @input [prompt] - Message to display when requesting input
+ * @output agentResult - Result returned by the agent
+ */
+export declare function waitForAgent(execute: boolean, agentId: string, context: object, prompt?: string): Promise<{
+    onSuccess: boolean;
+    onFailure: boolean;
+    agentResult: object;
+}>;
+//# sourceMappingURL=wait-for-agent.d.ts.map

package/dist/built-in-nodes/wait-for-agent.js

@@ -0,0 +1,26 @@
+import { getMockConfig } from './mock-types.js';
+/**
+ * @flowWeaver nodeType
+ * @input agentId - Agent/task identifier
+ * @input context - Context data to send to the agent
+ * @input [prompt] - Message to display when requesting input
+ * @output agentResult - Result returned by the agent
+ */
+export async function waitForAgent(execute, agentId, context, prompt) {
+    if (!execute)
+        return { onSuccess: false, onFailure: false, agentResult: {} };
+    // 1. Check mocks first
+    const mocks = getMockConfig();
+    if (mocks?.agents?.[agentId]) {
+        return { onSuccess: true, onFailure: false, agentResult: mocks.agents[agentId] };
+    }
+    // 2. Check agent channel (set by executor for pause/resume)
+    const channel = globalThis.__fw_agent_channel__;
+    if (channel) {
+        const result = await channel.request({ agentId, context, prompt });
+        return { onSuccess: true, onFailure: false, agentResult: result };
+    }
+    // 3. No mocks, no channel: no-op
+    return { onSuccess: true, onFailure: false, agentResult: {} };
+}
+//# sourceMappingURL=wait-for-agent.js.map

package/dist/chevrotain-parser/fan-parser.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @module chevrotain-parser/fan-parser
+ *
+ * Parser for @fanOut and @fanIn sugar annotations using Chevrotain.
+ *
+ * Syntax:
+ *   @fanOut Start.data -> a, b, c
+ *   @fanOut Start.data -> a.input1, b.input2
+ *   @fanIn a.result, b.result, c.result -> merge.inputs
+ *   @fanIn a, b, c -> merge.data
+ */
+export interface PortRef {
+    node: string;
+    port?: string;
+}
+export interface FanOutParseResult {
+    source: PortRef;
+    targets: PortRef[];
+}
+export interface FanInParseResult {
+    sources: PortRef[];
+    target: PortRef;
+}
+/**
+ * Parse a @fanOut line and return structured result.
+ * Returns null if the line is not a valid @fanOut declaration.
+ */
+export declare function parseFanOutLine(input: string, warnings: string[]): FanOutParseResult | null;
+/**
+ * Parse a @fanIn line and return structured result.
+ * Returns null if the line is not a valid @fanIn declaration.
+ */
+export declare function parseFanInLine(input: string, warnings: string[]): FanInParseResult | null;
+/**
+ * Get serialized grammar for documentation/diagram generation.
+ */
+export declare function getFanGrammar(): import("chevrotain").ISerializedGast[];
+//# sourceMappingURL=fan-parser.d.ts.map

package/dist/chevrotain-parser/fan-parser.js

@@ -0,0 +1,149 @@
+/**
+ * @module chevrotain-parser/fan-parser
+ *
+ * Parser for @fanOut and @fanIn sugar annotations using Chevrotain.
+ *
+ * Syntax:
+ *   @fanOut Start.data -> a, b, c
+ *   @fanOut Start.data -> a.input1, b.input2
+ *   @fanIn a.result, b.result, c.result -> merge.inputs
+ *   @fanIn a, b, c -> merge.data
+ */
+import { CstParser } from 'chevrotain';
+import { JSDocLexer, FanOutTag, FanInTag, Identifier, Arrow, Dot, Comma, allTokens, } from './tokens.js';
+// =============================================================================
+// Parser Definition
+// =============================================================================
+class FanParser extends CstParser {
+    constructor() {
+        super(allTokens);
+        this.performSelfAnalysis();
+    }
+    // @fanOut portRef Arrow portRef (Comma portRef)*
+    fanOutLine = this.RULE('fanOutLine', () => {
+        this.CONSUME(FanOutTag);
+        this.SUBRULE(this.portRef, { LABEL: 'source' });
+        this.CONSUME(Arrow);
+        this.SUBRULE2(this.portRef, { LABEL: 'firstTarget' });
+        this.MANY(() => {
+            this.CONSUME(Comma);
+            this.SUBRULE3(this.portRef, { LABEL: 'moreTargets' });
+        });
+    });
+    // @fanIn portRef (Comma portRef)* Arrow portRef
+    // Note: Because we can't look ahead past the comma-list to the arrow,
+    // we parse as: @fanIn portRefList Arrow portRef
+    // The last element after Arrow is the target; everything before is sources.
+    fanInLine = this.RULE('fanInLine', () => {
+        this.CONSUME(FanInTag);
+        this.SUBRULE(this.portRef, { LABEL: 'firstSource' });
+        this.MANY(() => {
+            this.CONSUME(Comma);
+            this.SUBRULE2(this.portRef, { LABEL: 'moreSources' });
+        });
+        this.CONSUME(Arrow);
+        this.SUBRULE3(this.portRef, { LABEL: 'target' });
+    });
+    // portRef: Identifier (Dot Identifier)?
+    portRef = this.RULE('portRef', () => {
+        this.CONSUME(Identifier, { LABEL: 'nodeName' });
+        this.OPTION(() => {
+            this.CONSUME(Dot);
+            this.CONSUME2(Identifier, { LABEL: 'portName' });
+        });
+    });
+}
+// =============================================================================
+// Parser Instance (singleton)
+// =============================================================================
+const parserInstance = new FanParser();
+// =============================================================================
+// CST Visitor
+// =============================================================================
+const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
+class FanVisitor extends BaseVisitor {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    fanOutLine(ctx) {
+        const source = this.portRef(ctx.source[0].children);
+        const targets = [];
+        targets.push(this.portRef(ctx.firstTarget[0].children));
+        if (ctx.moreTargets) {
+            for (const t of ctx.moreTargets) {
+                targets.push(this.portRef(t.children));
+            }
+        }
+        return { source, targets };
+    }
+    fanInLine(ctx) {
+        const sources = [];
+        sources.push(this.portRef(ctx.firstSource[0].children));
+        if (ctx.moreSources) {
+            for (const s of ctx.moreSources) {
+                sources.push(this.portRef(s.children));
+            }
+        }
+        const target = this.portRef(ctx.target[0].children);
+        return { sources, target };
+    }
+    portRef(ctx) {
+        const node = ctx.nodeName[0].image;
+        const port = ctx.portName?.[0]?.image;
+        return port ? { node, port } : { node };
+    }
+}
+const visitorInstance = new FanVisitor();
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Parse a @fanOut line and return structured result.
+ * Returns null if the line is not a valid @fanOut declaration.
+ */
+export function parseFanOutLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0 || lexResult.tokens.length === 0)
+        return null;
+    if (lexResult.tokens[0].tokenType !== FanOutTag)
+        return null;
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.fanOutLine();
+    if (parserInstance.errors.length > 0) {
+        const truncatedInput = input.length > 80 ? input.substring(0, 80) + '...' : input;
+        warnings.push(`Failed to parse @fanOut line: "${truncatedInput}"\n` +
+            `  Error: ${parserInstance.errors[0].message}\n` +
+            `  Expected format: @fanOut source.port -> target1, target2, target3`);
+        return null;
+    }
+    return visitorInstance.visit(cst);
+}
+/**
+ * Parse a @fanIn line and return structured result.
+ * Returns null if the line is not a valid @fanIn declaration.
+ */
+export function parseFanInLine(input, warnings) {
+    const lexResult = JSDocLexer.tokenize(input);
+    if (lexResult.errors.length > 0 || lexResult.tokens.length === 0)
+        return null;
+    if (lexResult.tokens[0].tokenType !== FanInTag)
+        return null;
+    parserInstance.input = lexResult.tokens;
+    const cst = parserInstance.fanInLine();
+    if (parserInstance.errors.length > 0) {
+        const truncatedInput = input.length > 80 ? input.substring(0, 80) + '...' : input;
+        warnings.push(`Failed to parse @fanIn line: "${truncatedInput}"\n` +
+            `  Error: ${parserInstance.errors[0].message}\n` +
+            `  Expected format: @fanIn source1.port, source2.port -> target.port`);
+        return null;
+    }
+    return visitorInstance.visit(cst);
+}
+/**
+ * Get serialized grammar for documentation/diagram generation.
+ */
+export function getFanGrammar() {
+    return parserInstance.getSerializedGastProductions();
+}
+//# sourceMappingURL=fan-parser.js.map

package/dist/chevrotain-parser/grammar-diagrams.d.ts

@@ -13,6 +13,7 @@ export interface GrammarCollection {
     scope: ISerializedGast[];
     path: ISerializedGast[];
     map: ISerializedGast[];
+    fan: ISerializedGast[];
     triggerCancel: ISerializedGast[];
 }
 /**

package/dist/chevrotain-parser/grammar-diagrams.js

@@ -12,6 +12,7 @@ import { getScopeGrammar } from './scope-parser.js';
 import { getPathGrammar } from './path-parser.js';
 import { getMapGrammar } from './map-parser.js';
 import { getTriggerCancelGrammar } from './trigger-cancel-parser.js';
+import { getFanGrammar } from './fan-parser.js';
 export function serializedToEBNF(productions) {
     const lines = [];
     for (const prod of productions) {
@@ -129,6 +130,7 @@ export function getAllGrammars() {
         scope: getScopeGrammar(),
         path: getPathGrammar(),
         map: getMapGrammar(),
+        fan: getFanGrammar(),
         triggerCancel: getTriggerCancelGrammar(),
     };
 }
@@ -147,6 +149,7 @@ export function generateGrammarDiagrams() {
         ...grammars.scope,
         ...grammars.path,
         ...grammars.map,
+        ...grammars.fan,
         ...grammars.triggerCancel,
     ];
     // createSyntaxDiagramsCode returns a complete HTML document

package/dist/chevrotain-parser/index.d.ts

@@ -4,7 +4,7 @@
  * Chevrotain-based parsers for JSDoc annotations.
  * Provides structured parsing for @input, @output, @node, @connect, and @position.
  */
-export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
+export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, FanOutTag, FanInTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
 export { parsePortLine, getPortGrammar } from './port-parser.js';
 export type { PortParseResult } from './port-parser.js';
 export { parseNodeLine, getNodeGrammar } from './node-parser.js';
@@ -19,6 +19,8 @@ export { parseMapLine, getMapGrammar } from './map-parser.js';
 export type { MapParseResult } from './map-parser.js';
 export { parsePathLine, getPathGrammar } from './path-parser.js';
 export type { PathParseResult, PathStep } from './path-parser.js';
+export { parseFanOutLine, parseFanInLine } from './fan-parser.js';
+export type { FanOutParseResult, FanInParseResult, PortRef } from './fan-parser.js';
 export { parseTriggerLine, parseCancelOnLine, parseRetriesLine, parseTimeoutLine, parseThrottleLine } from './trigger-cancel-parser.js';
 export type { TriggerParseResult, CancelOnParseResult, ThrottleParseResult } from './trigger-cancel-parser.js';
 export { generateGrammarDiagrams, getAllGrammars, serializedToEBNF } from './grammar-diagrams.js';

package/dist/chevrotain-parser/index.js

@@ -5,7 +5,7 @@
  * Provides structured parsing for @input, @output, @node, @connect, and @position.
  */
 // Token exports (for advanced use cases)
-export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
+export { JSDocLexer, allTokens, InputTag, OutputTag, NodeTag, ConnectTag, PositionTag, ScopeTag, MapTag, PathTag, FanOutTag, FanInTag, TriggerTag, CancelOnTag, RetriesTag, TimeoutTag, ThrottleTag, } from './tokens.js';
 // Port parser
 export { parsePortLine, getPortGrammar } from './port-parser.js';
 // Node parser
@@ -20,6 +20,8 @@ export { parseScopeLine, getScopeGrammar } from './scope-parser.js';
 export { parseMapLine, getMapGrammar } from './map-parser.js';
 // Path parser
 export { parsePathLine, getPathGrammar } from './path-parser.js';
+// Fan-out / Fan-in parser
+export { parseFanOutLine, parseFanInLine } from './fan-parser.js';
 // Trigger/cancel/retries/timeout/throttle parser
 export { parseTriggerLine, parseCancelOnLine, parseRetriesLine, parseTimeoutLine, parseThrottleLine } from './trigger-cancel-parser.js';
 // Grammar diagram generation

package/dist/chevrotain-parser/tokens.d.ts

@@ -17,6 +17,8 @@ export declare const PositionTag: import("chevrotain").TokenType;
 export declare const ScopeTag: import("chevrotain").TokenType;
 export declare const MapTag: import("chevrotain").TokenType;
 export declare const PathTag: import("chevrotain").TokenType;
+export declare const FanOutTag: import("chevrotain").TokenType;
+export declare const FanInTag: import("chevrotain").TokenType;
 export declare const TriggerTag: import("chevrotain").TokenType;
 export declare const CancelOnTag: import("chevrotain").TokenType;
 export declare const RetriesTag: import("chevrotain").TokenType;

package/dist/chevrotain-parser/tokens.js

@@ -61,6 +61,14 @@ export const PathTag = createToken({
     name: 'PathTag',
     pattern: /@path\b/,
 });
+export const FanOutTag = createToken({
+    name: 'FanOutTag',
+    pattern: /@fanOut\b/,
+});
+export const FanInTag = createToken({
+    name: 'FanInTag',
+    pattern: /@fanIn\b/,
+});
 export const TriggerTag = createToken({
     name: 'TriggerTag',
     pattern: /@trigger\b/,
@@ -315,6 +323,8 @@ export const allTokens = [
     ScopeTag,
     MapTag,
     PathTag,
+    FanOutTag,
+    FanInTag,
     TriggerTag,
     CancelOnTag,
     RetriesTag,

package/dist/cli/commands/diagram.d.ts

@@ -1,5 +1,5 @@
 /**
- * Diagram command — generates SVG diagrams from workflow files.
+ * Diagram command — generates SVG or interactive HTML diagrams from workflow files.
  */
 export interface DiagramCommandOptions {
     theme?: 'dark' | 'light';
@@ -8,6 +8,7 @@ export interface DiagramCommandOptions {
     showPortLabels?: boolean;
     workflowName?: string;
     output?: string;
+    format?: 'svg' | 'html';
 }
 export declare function diagramCommand(input: string, options?: DiagramCommandOptions): Promise<void>;
 //# sourceMappingURL=diagram.d.ts.map

package/dist/cli/commands/diagram.js

@@ -1,28 +1,31 @@
 /* eslint-disable no-console */
 /**
- * Diagram command — generates SVG diagrams from workflow files.
+ * Diagram command — generates SVG or interactive HTML diagrams from workflow files.
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { fileToSVG } from '../../diagram/index.js';
+import { fileToSVG, fileToHTML } from '../../diagram/index.js';
 import { logger } from '../utils/logger.js';
 import { getErrorMessage } from '../../utils/error-utils.js';
 export async function diagramCommand(input, options = {}) {
-    const { output, ...diagramOptions } = options;
+    const { output, format = 'svg', ...diagramOptions } = options;
     const filePath = path.resolve(input);
     if (!fs.existsSync(filePath)) {
         logger.error(`File not found: ${filePath}`);
         process.exit(1);
     }
     try {
-        const svg = fileToSVG(filePath, diagramOptions);
+        const isHtml = format === 'html';
+        const result = isHtml
+            ? fileToHTML(filePath, diagramOptions)
+            : fileToSVG(filePath, diagramOptions);
         if (output) {
             const outputPath = path.resolve(output);
-            fs.writeFileSync(outputPath, svg, 'utf-8');
+            fs.writeFileSync(outputPath, result, 'utf-8');
             logger.success(`Diagram written to ${outputPath}`);
         }
         else {
-            process.stdout.write(svg);
+            process.stdout.write(result);
         }
     }
     catch (error) {