@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/body-generator.js

@@ -1,35 +0,0 @@
-import { generateControlFlowWithExecutionContext } from "./generator/unified.js";
-/**
- * Generates executable function body code from workflow ASTs.
- * Delegates to the unified control-flow generator for code emission.
- */
-export class BodyGenerator {
-    /**
-     * Generates a workflow function body that uses an execution context for
-     * tracing, error handling, and runtime state management.
-     *
-     * @param workflow - The workflow AST defining the graph structure.
-     * @param nodeTypes - The node type definitions referenced by the workflow.
-     * @param isAsync - Whether to generate async code. Defaults to true.
-     * @param production - If true, omits debug event emissions. Defaults to false.
-     * @param bundleMode - If true, generates code suitable for bundled deployment. Defaults to false.
-     * @returns The generated function body as a string.
-     */
-    generateWithExecutionContext(workflow, nodeTypes, isAsync = true, production = false, bundleMode = false) {
-        return generateControlFlowWithExecutionContext(workflow, nodeTypes, isAsync, production, bundleMode);
-    }
-    /**
-     * Generates a workflow function body using default settings (async, non-production, non-bundled).
-     * Convenience method that wraps {@link generateWithExecutionContext}.
-     *
-     * @param workflow - The workflow AST defining the graph structure.
-     * @param nodeTypes - The node type definitions referenced by the workflow.
-     * @returns The generated function body as a string.
-     */
-    generateDirectCode(workflow, nodeTypes) {
-        return generateControlFlowWithExecutionContext(workflow, nodeTypes, true, false, false);
-    }
-}
-/** Pre-instantiated singleton of {@link BodyGenerator} for convenient use. */
-export const bodyGenerator = new BodyGenerator();
-//# sourceMappingURL=body-generator.js.map

package/dist/built-in-nodes/coercion-types.js

@@ -1,61 +0,0 @@
-/**
- * Synthetic node type definitions for explicit type coercion.
- *
- * These are compiler-internal node types created by @coerce macros.
- * They generate inline JavaScript coercion expressions instead of function calls.
- */
-/** Maps coercion target type keyword to the synthetic node type name */
-export const COERCE_TYPE_MAP = {
-    string: '__fw_toString',
-    number: '__fw_toNumber',
-    boolean: '__fw_toBoolean',
-    json: '__fw_toJSON',
-    object: '__fw_parseJSON',
-};
-/** Maps synthetic node type name to the inline JS expression */
-export const COERCE_EXPRESSIONS = {
-    __fw_toString: 'String',
-    __fw_toNumber: 'Number',
-    __fw_toBoolean: 'Boolean',
-    __fw_toJSON: 'JSON.stringify',
-    __fw_parseJSON: 'JSON.parse',
-};
-function makeCoercionNodeType(name, outputType, outputTsType) {
-    return {
-        type: 'NodeType',
-        name,
-        functionName: name,
-        expression: true,
-        isAsync: false,
-        hasSuccessPort: true,
-        hasFailurePort: true,
-        executeWhen: 'CONJUNCTION',
-        variant: 'COERCION',
-        inputs: {
-            execute: { dataType: 'STEP', label: 'Execute' },
-            value: { dataType: 'ANY', label: 'Value', tsType: 'unknown' },
-        },
-        outputs: {
-            onSuccess: { dataType: 'STEP', label: 'On Success', isControlFlow: true },
-            onFailure: { dataType: 'STEP', label: 'On Failure', failure: true, isControlFlow: true },
-            result: { dataType: outputType, label: 'Result', tsType: outputTsType },
-        },
-        visuals: {
-            color: '#0d9488',
-            icon: 'transform',
-            tags: [{ label: 'coerce' }],
-        },
-    };
-}
-export const COERCION_NODE_TYPES = {
-    __fw_toString: makeCoercionNodeType('__fw_toString', 'STRING', 'string'),
-    __fw_toNumber: makeCoercionNodeType('__fw_toNumber', 'NUMBER', 'number'),
-    __fw_toBoolean: makeCoercionNodeType('__fw_toBoolean', 'BOOLEAN', 'boolean'),
-    __fw_toJSON: makeCoercionNodeType('__fw_toJSON', 'STRING', 'string'),
-    __fw_parseJSON: makeCoercionNodeType('__fw_parseJSON', 'OBJECT', 'object'),
-};
-/** Check if a function name is a coercion node type */
-export function isCoercionNode(functionName) {
-    return functionName in COERCION_NODE_TYPES;
-}
-//# sourceMappingURL=coercion-types.js.map

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

@@ -1,29 +0,0 @@
-import { getMockConfig } from './mock-types.js';
-/**
- * @flowWeaver nodeType
- * @input duration - Duration to sleep (e.g. "30s", "5m", "1h", "2d")
- * @output elapsed - Always true after sleep completes
- */
-export async function delay(execute, duration) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, elapsed: false };
-    const mocks = getMockConfig();
-    if (mocks?.fast) {
-        // Fast mode: skip real sleep, keep async behavior with 1ms
-        await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-    else {
-        const ms = parseDuration(duration);
-        await new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    return { onSuccess: true, onFailure: false, elapsed: true };
-}
-function parseDuration(duration) {
-    const match = duration.match(/^(\d+)(ms|s|m|h|d)$/);
-    if (!match)
-        return 0;
-    const [, value, unit] = match;
-    const multipliers = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
-    return parseInt(value) * (multipliers[unit] || 0);
-}
-//# sourceMappingURL=delay.js.map

package/dist/built-in-nodes/generated-registry.js

@@ -1,299 +0,0 @@
-/**
- * DO NOT EDIT - generated by scripts/generate-built-in-registry.ts
- *
- * Registry of built-in node types for auto-injection into the parser.
- * Generated from the actual source files in src/built-in-nodes/.
- */
-export const BUILT_IN_NODE_TYPES = [
-    {
-        type: 'NodeType',
-        name: 'delay',
-        functionName: 'delay',
-        isAsync: true,
-        hasSuccessPort: true,
-        hasFailurePort: true,
-        executeWhen: 'CONJUNCTION',
-        variant: 'FUNCTION',
-        inputs: {
-            execute: { dataType: 'STEP', label: 'Execute' },
-            duration: { dataType: 'STRING', label: 'Duration to sleep (e.g. "30s", "5m", "1h", "2d")', tsType: 'string' },
-        },
-        outputs: {
-            onSuccess: { dataType: 'STEP', label: 'On Success', isControlFlow: true },
-            onFailure: { dataType: 'STEP', label: 'On Failure', isControlFlow: true, failure: true },
-            elapsed: { dataType: 'BOOLEAN', label: 'Always true after sleep completes', tsType: 'boolean' },
-        },
-        helperText: `
-function __fw_getMockConfig() {
-    return globalThis.__fw_mocks__;
-}
-
-function __fw_lookupMock(section, key) {
-    if (!section)
-        return undefined;
-    const nodeId = globalThis.__fw_current_node_id__;
-    if (nodeId) {
-        const qualified = section[\`\${nodeId}:\${key}\`];
-        if (qualified !== undefined)
-            return qualified;
-    }
-    return section[key];
-}
-`.trim(),
-        helperTextProduction: undefined,
-        functionText: `
-async function delay(execute, duration) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, elapsed: false };
-    const mocks = __fw_getMockConfig();
-    if (mocks?.fast) {
-        await new Promise((resolve) => setTimeout(resolve, 1));
-    }
-    else {
-        const ms = __fw_parseDuration(duration);
-        await new Promise((resolve) => setTimeout(resolve, ms));
-    }
-    return { onSuccess: true, onFailure: false, elapsed: true };
-}
-function __fw_parseDuration(duration) {
-    const match = duration.match(/^(\\d+)(ms|s|m|h|d)$/);
-    if (!match)
-        return 0;
-    const [, value, unit] = match;
-    const multipliers = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
-    return parseInt(value) * (multipliers[unit] || 0);
-}
-`.trim(),
-        functionTextProduction: `
-async function delay(execute, duration) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, elapsed: false };
-    const ms = __fw_parseDuration(duration);
-    await new Promise((resolve) => setTimeout(resolve, ms));
-    return { onSuccess: true, onFailure: false, elapsed: true };
-}
-function __fw_parseDuration(duration) {
-    const match = duration.match(/^(\\d+)(ms|s|m|h|d)$/);
-    if (!match)
-        return 0;
-    const [, value, unit] = match;
-    const multipliers = { ms: 1, s: 1000, m: 60000, h: 3600000, d: 86400000 };
-    return parseInt(value) * (multipliers[unit] || 0);
-}
-`.trim(),
-    },
-    {
-        type: 'NodeType',
-        name: 'waitForEvent',
-        functionName: 'waitForEvent',
-        isAsync: true,
-        hasSuccessPort: true,
-        hasFailurePort: true,
-        executeWhen: 'CONJUNCTION',
-        variant: 'FUNCTION',
-        inputs: {
-            execute: { dataType: 'STEP', label: 'Execute' },
-            eventName: { dataType: 'STRING', label: 'Event name to wait for (e.g. "app/approval.received")', tsType: 'string' },
-            match: { dataType: 'STRING', label: 'Field to match between trigger and waited event (e.g. "data.requestId")', tsType: 'string', optional: true },
-            timeout: { dataType: 'STRING', label: 'Max wait time (e.g. "24h", "7d"). Empty = no timeout', tsType: 'string', optional: true },
-        },
-        outputs: {
-            onSuccess: { dataType: 'STEP', label: 'On Success', isControlFlow: true },
-            onFailure: { dataType: 'STEP', label: 'On Failure', isControlFlow: true, failure: true },
-            eventData: { dataType: 'OBJECT', label: 'The received event\'s data payload', tsType: 'object' },
-        },
-        helperText: `
-function __fw_getMockConfig() {
-    return globalThis.__fw_mocks__;
-}
-
-function __fw_lookupMock(section, key) {
-    if (!section)
-        return undefined;
-    const nodeId = globalThis.__fw_current_node_id__;
-    if (nodeId) {
-        const qualified = section[\`\${nodeId}:\${key}\`];
-        if (qualified !== undefined)
-            return qualified;
-    }
-    return section[key];
-}
-`.trim(),
-        helperTextProduction: undefined,
-        functionText: `
-async function waitForEvent(execute, eventName, match, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, eventData: {} };
-    const mocks = __fw_getMockConfig();
-    if (mocks) {
-        const mockData = __fw_lookupMock(mocks.events, eventName);
-        if (mockData !== undefined) {
-            return { onSuccess: true, onFailure: false, eventData: mockData };
-        }
-        return { onSuccess: false, onFailure: true, eventData: {} };
-    }
-    return { onSuccess: true, onFailure: false, eventData: {} };
-}
-`.trim(),
-        functionTextProduction: `
-async function waitForEvent(execute, eventName, match, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, eventData: {} };
-    return { onSuccess: true, onFailure: false, eventData: {} };
-}
-`.trim(),
-    },
-    {
-        type: 'NodeType',
-        name: 'invokeWorkflow',
-        functionName: 'invokeWorkflow',
-        isAsync: true,
-        hasSuccessPort: true,
-        hasFailurePort: true,
-        executeWhen: 'CONJUNCTION',
-        variant: 'FUNCTION',
-        inputs: {
-            execute: { dataType: 'STEP', label: 'Execute' },
-            functionId: { dataType: 'STRING', label: 'Function ID of the workflow to invoke (e.g. "my-service/sub-workflow")', tsType: 'string' },
-            payload: { dataType: 'OBJECT', label: 'Data to pass as event.data to the invoked function', tsType: 'object' },
-            timeout: { dataType: 'STRING', label: 'Max wait time (e.g. "1h")', tsType: 'string', optional: true },
-        },
-        outputs: {
-            onSuccess: { dataType: 'STEP', label: 'On Success', isControlFlow: true },
-            onFailure: { dataType: 'STEP', label: 'On Failure', isControlFlow: true, failure: true },
-            result: { dataType: 'OBJECT', label: 'Return value from the invoked function', tsType: 'object' },
-        },
-        helperText: `
-function __fw_getMockConfig() {
-    return globalThis.__fw_mocks__;
-}
-
-function __fw_lookupMock(section, key) {
-    if (!section)
-        return undefined;
-    const nodeId = globalThis.__fw_current_node_id__;
-    if (nodeId) {
-        const qualified = section[\`\${nodeId}:\${key}\`];
-        if (qualified !== undefined)
-            return qualified;
-    }
-    return section[key];
-}
-`.trim(),
-        helperTextProduction: undefined,
-        functionText: `
-async function invokeWorkflow(execute, functionId, payload, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, result: {} };
-    const mocks = __fw_getMockConfig();
-    if (mocks) {
-        const mockResult = __fw_lookupMock(mocks.invocations, functionId);
-        if (mockResult !== undefined) {
-            return { onSuccess: true, onFailure: false, result: mockResult };
-        }
-        return { onSuccess: false, onFailure: true, result: {} };
-    }
-    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: {} };
-        }
-    }
-    return { onSuccess: true, onFailure: false, result: {} };
-}
-`.trim(),
-        functionTextProduction: `
-async function invokeWorkflow(execute, functionId, payload, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, result: {} };
-    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: {} };
-        }
-    }
-    return { onSuccess: true, onFailure: false, result: {} };
-}
-`.trim(),
-    },
-    {
-        type: 'NodeType',
-        name: 'waitForAgent',
-        functionName: 'waitForAgent',
-        isAsync: true,
-        hasSuccessPort: true,
-        hasFailurePort: true,
-        executeWhen: 'CONJUNCTION',
-        variant: 'FUNCTION',
-        inputs: {
-            execute: { dataType: 'STEP', label: 'Execute' },
-            agentId: { dataType: 'STRING', label: 'Agent/task identifier', tsType: 'string' },
-            context: { dataType: 'OBJECT', label: 'Context data to send to the agent', tsType: 'object' },
-            prompt: { dataType: 'STRING', label: 'Message to display when requesting input', tsType: 'string', optional: true },
-        },
-        outputs: {
-            onSuccess: { dataType: 'STEP', label: 'On Success', isControlFlow: true },
-            onFailure: { dataType: 'STEP', label: 'On Failure', isControlFlow: true, failure: true },
-            agentResult: { dataType: 'OBJECT', label: 'Result returned by the agent', tsType: 'object' },
-        },
-        helperText: `
-function __fw_getMockConfig() {
-    return globalThis.__fw_mocks__;
-}
-
-function __fw_lookupMock(section, key) {
-    if (!section)
-        return undefined;
-    const nodeId = globalThis.__fw_current_node_id__;
-    if (nodeId) {
-        const qualified = section[\`\${nodeId}:\${key}\`];
-        if (qualified !== undefined)
-            return qualified;
-    }
-    return section[key];
-}
-`.trim(),
-        helperTextProduction: undefined,
-        functionText: `
-async function waitForAgent(execute, agentId, context, prompt) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, agentResult: {} };
-    const mocks = __fw_getMockConfig();
-    const mockResult = __fw_lookupMock(mocks?.agents, agentId);
-    if (mockResult !== undefined) {
-        return { onSuccess: true, onFailure: false, agentResult: mockResult };
-    }
-    if (mocks?.agents) {
-        return { onSuccess: false, onFailure: true, agentResult: {} };
-    }
-    const channel = globalThis.__fw_agent_channel__;
-    if (channel) {
-        const result = await channel.request({ agentId, context, prompt });
-        return { onSuccess: true, onFailure: false, agentResult: result };
-    }
-    return { onSuccess: true, onFailure: false, agentResult: {} };
-}
-`.trim(),
-        functionTextProduction: `
-async function waitForAgent(execute, agentId, context, prompt) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, agentResult: {} };
-    const channel = globalThis.__fw_agent_channel__;
-    if (channel) {
-        const result = await channel.request({ agentId, context, prompt });
-        return { onSuccess: true, onFailure: false, agentResult: result };
-    }
-    return { onSuccess: true, onFailure: false, agentResult: {} };
-}
-`.trim(),
-    },
-];
-//# sourceMappingURL=generated-registry.js.map

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

@@ -1,36 +0,0 @@
-import { getMockConfig, lookupMock } from './mock-types.js';
-/**
- * @flowWeaver nodeType
- * @input functionId - Function ID of the workflow to invoke (e.g. "my-service/sub-workflow")
- * @input payload - Data to pass as event.data to the invoked function
- * @input [timeout] - Max wait time (e.g. "1h")
- * @output result - Return value from the invoked function
- */
-export async function invokeWorkflow(execute, functionId, payload, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, result: {} };
-    const mocks = getMockConfig();
-    if (mocks) {
-        // Mock mode — look up result by functionId (supports instance-qualified keys)
-        const mockResult = lookupMock(mocks.invocations, functionId);
-        if (mockResult !== undefined) {
-            return { onSuccess: true, onFailure: false, result: mockResult };
-        }
-        // No mock data for this functionId — simulate failure
-        return { onSuccess: false, onFailure: true, result: {} };
-    }
-    // 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.js

@@ -1,42 +0,0 @@
-/**
- * Type definitions for the mock configuration used during local testing.
- * When present on globalThis.__fw_mocks__, built-in nodes use mock data
- * instead of their default no-op/sleep behavior.
- */
-/**
- * Read the mock config from globalThis, returning undefined if not set.
- */
-export function getMockConfig() {
-    return globalThis.__fw_mocks__;
-}
-/**
- * Look up a mock value from a section, supporting instance-qualified keys.
- *
- * Checks "instanceId:key" first (for per-node targeting), then falls back
- * to plain "key". The instance ID comes from __fw_current_node_id__ which
- * the generated code sets before each node invocation.
- *
- * @example
- * ```json
- * {
- *   "invocations": {
- *     "retryCall:api/process": { "status": "ok" },
- *     "api/process": { "status": "default" }
- *   }
- * }
- * ```
- * When the node "retryCall" invokes "api/process", it gets `{ status: "ok" }`.
- * Any other node invoking "api/process" gets `{ status: "default" }`.
- */
-export function lookupMock(section, key) {
-    if (!section)
-        return undefined;
-    const nodeId = globalThis.__fw_current_node_id__;
-    if (nodeId) {
-        const qualified = section[`${nodeId}:${key}`];
-        if (qualified !== undefined)
-            return qualified;
-    }
-    return section[key];
-}
-//# sourceMappingURL=mock-types.js.map

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

@@ -1,31 +0,0 @@
-import { getMockConfig, lookupMock } 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 (supports instance-qualified keys)
-    const mocks = getMockConfig();
-    const mockResult = lookupMock(mocks?.agents, agentId);
-    if (mockResult !== undefined) {
-        return { onSuccess: true, onFailure: false, agentResult: mockResult };
-    }
-    // Mocks section exists but key not found — fail like waitForEvent/invokeWorkflow
-    if (mocks?.agents) {
-        return { onSuccess: false, onFailure: true, agentResult: {} };
-    }
-    // 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/built-in-nodes/wait-for-event.js

@@ -1,25 +0,0 @@
-import { getMockConfig, lookupMock } from './mock-types.js';
-/**
- * @flowWeaver nodeType
- * @input eventName - Event name to wait for (e.g. "app/approval.received")
- * @input [match] - Field to match between trigger and waited event (e.g. "data.requestId")
- * @input [timeout] - Max wait time (e.g. "24h", "7d"). Empty = no timeout
- * @output eventData - The received event's data payload
- */
-export async function waitForEvent(execute, eventName, match, timeout) {
-    if (!execute)
-        return { onSuccess: false, onFailure: false, eventData: {} };
-    const mocks = getMockConfig();
-    if (mocks) {
-        // Mock mode — look up event data by name (supports instance-qualified keys)
-        const mockData = lookupMock(mocks.events, eventName);
-        if (mockData !== undefined) {
-            return { onSuccess: true, onFailure: false, eventData: mockData };
-        }
-        // No mock data for this event — simulate timeout
-        return { onSuccess: false, onFailure: true, eventData: {} };
-    }
-    // No mocks: original no-op behavior (always succeeds)
-    return { onSuccess: true, onFailure: false, eventData: {} };
-}
-//# sourceMappingURL=wait-for-event.js.map

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

@@ -1,103 +0,0 @@
-/**
- * @module chevrotain-parser/coerce-parser
- *
- * Parser for @coerce sugar annotation using Chevrotain.
- *
- * Syntax:
- *   @coerce instanceId sourceNode.port -> targetNode.port as targetType
- *
- * Where targetType is one of: string, number, boolean, json, object
- */
-import { CstParser } from 'chevrotain';
-import { JSDocLexer, CoerceTag, Identifier, Arrow, Dot, AsKeyword, allTokens, } from './tokens.js';
-const VALID_COERCE_TYPES = new Set(['string', 'number', 'boolean', 'json', 'object']);
-// =============================================================================
-// Parser Definition
-// =============================================================================
-class CoerceParser extends CstParser {
-    constructor() {
-        super(allTokens);
-        this.performSelfAnalysis();
-    }
-    // @coerce Identifier portRef Arrow portRef AsKeyword Identifier
-    coerceLine = this.RULE('coerceLine', () => {
-        this.CONSUME(CoerceTag);
-        this.CONSUME(Identifier, { LABEL: 'instanceId' });
-        this.SUBRULE(this.portRef, { LABEL: 'source' });
-        this.CONSUME(Arrow);
-        this.SUBRULE2(this.portRef, { LABEL: 'target' });
-        this.CONSUME(AsKeyword);
-        this.CONSUME2(Identifier, { LABEL: 'typeName' });
-    });
-    // portRef: Identifier Dot Identifier
-    portRef = this.RULE('portRef', () => {
-        this.CONSUME(Identifier, { LABEL: 'nodeName' });
-        this.CONSUME(Dot);
-        this.CONSUME2(Identifier, { LABEL: 'portName' });
-    });
-}
-// =============================================================================
-// Parser Instance (singleton)
-// =============================================================================
-const parserInstance = new CoerceParser();
-// =============================================================================
-// CST Visitor
-// =============================================================================
-const BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
-class CoerceVisitor extends BaseVisitor {
-    constructor() {
-        super();
-        this.validateVisitor();
-    }
-    coerceLine(ctx) {
-        const instanceId = ctx.instanceId[0].image;
-        const source = this.portRef(ctx.source[0].children);
-        const target = this.portRef(ctx.target[0].children);
-        const targetType = ctx.typeName[0].image;
-        return { instanceId, source, target, targetType };
-    }
-    portRef(ctx) {
-        return {
-            node: ctx.nodeName[0].image,
-            port: ctx.portName[0].image,
-        };
-    }
-}
-const visitorInstance = new CoerceVisitor();
-// =============================================================================
-// Public API
-// =============================================================================
-/**
- * Parse a @coerce line and return structured result.
- * Returns null if the line is not a valid @coerce declaration.
- */
-export function parseCoerceLine(input, warnings) {
-    const lexResult = JSDocLexer.tokenize(input);
-    if (lexResult.errors.length > 0 || lexResult.tokens.length === 0)
-        return null;
-    if (lexResult.tokens[0].tokenType !== CoerceTag)
-        return null;
-    parserInstance.input = lexResult.tokens;
-    const cst = parserInstance.coerceLine();
-    if (parserInstance.errors.length > 0) {
-        const truncatedInput = input.length > 80 ? input.substring(0, 80) + '...' : input;
-        warnings.push(`Failed to parse @coerce line: "${truncatedInput}"\n` +
-            `  Error: ${parserInstance.errors[0].message}\n` +
-            `  Expected format: @coerce instanceId source.port -> target.port as type`);
-        return null;
-    }
-    const result = visitorInstance.visit(cst);
-    // Validate the target type
-    if (!VALID_COERCE_TYPES.has(result.targetType)) {
-        warnings.push(`@coerce: invalid target type "${result.targetType}". Valid types: ${[...VALID_COERCE_TYPES].join(', ')}`);
-        return null;
-    }
-    return result;
-}
-/**
- * Get serialized grammar for documentation/diagram generation.
- */
-export function getCoerceGrammar() {
-    return parserInstance.getSerializedGastProductions();
-}
-//# sourceMappingURL=coerce-parser.js.map