@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-KMWCCOUJ.js

@@ -0,0 +1,1444 @@
+import {
+  Arrow,
+  AsKeyword,
+  CancelOnTag,
+  CoerceTag,
+  Colon,
+  ColorPrefix,
+  Comma,
+  ConnectTag,
+  CstParser,
+  Dot,
+  Equals,
+  ExprPrefix,
+  FanInTag,
+  FanOutTag,
+  IconPrefix,
+  Identifier,
+  Integer,
+  LBracket,
+  LParen,
+  LabelPrefix,
+  MapTag,
+  MinimizedKeyword,
+  NodeTag,
+  OverKeyword,
+  PathTag,
+  PortLabelPrefix,
+  PortOrderPrefix,
+  PullExecutionPrefix,
+  RBracket,
+  RParen,
+  RetriesTag,
+  ScopeTag,
+  SizePrefix,
+  StringLiteral,
+  SuppressPrefix,
+  TagsPrefix,
+  ThrottleTag,
+  TimeoutTag,
+  TriggerTag,
+  allTokens,
+  createSyntaxDiagramsCode,
+  getPortGrammar,
+  lexTaggedLine,
+  lineFailure,
+  runRule,
+  unquoteStringLiteral
+} from "./chunk-QYPORSLO.js";
+
+// src/chevrotain-parser/node-parser.ts
+var NodeParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // Entry rule for node line
+  // @node instanceId nodeType [parentNode.scope] [attributes]
+  nodeLine = this.RULE("nodeLine", () => {
+    this.CONSUME(NodeTag);
+    this.CONSUME(Identifier, { LABEL: "instanceId" });
+    this.CONSUME2(Identifier, { LABEL: "nodeType" });
+    this.OPTION(() => {
+      this.SUBRULE(this.parentScopeRef);
+    });
+    this.MANY(() => {
+      this.SUBRULE(this.attributeBracket);
+    });
+  });
+  // parent.scope
+  parentScopeRef = this.RULE("parentScopeRef", () => {
+    this.CONSUME(Identifier, { LABEL: "parentNode" });
+    this.CONSUME(Dot);
+    this.CONSUME2(Identifier, { LABEL: "scopeName" });
+  });
+  // [label: "...", expr: port="value", portOrder: port=N, portLabel: port="label", minimized, pullExecution: triggerPort, size: W H]
+  attributeBracket = this.RULE("attributeBracket", () => {
+    this.CONSUME(LBracket);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.OR([
+          { ALT: () => this.SUBRULE(this.labelAttr) },
+          { ALT: () => this.SUBRULE(this.exprAttr) },
+          { ALT: () => this.SUBRULE(this.portOrderAttr) },
+          { ALT: () => this.SUBRULE(this.portLabelAttr) },
+          { ALT: () => this.SUBRULE(this.minimizedAttr) },
+          { ALT: () => this.SUBRULE(this.pullExecutionAttr) },
+          { ALT: () => this.SUBRULE(this.sizeAttr) },
+          { ALT: () => this.SUBRULE(this.colorAttr) },
+          { ALT: () => this.SUBRULE(this.iconAttr) },
+          { ALT: () => this.SUBRULE(this.tagsAttr) },
+          { ALT: () => this.SUBRULE(this.suppressAttr) },
+          // Catch-all LAST: any `key: "value"` not claimed above lands in the
+          // node's `attributes` for a pack to read. INVARIANT: every named
+          // attribute above must have its OWN prefix token (label:, color:,
+          // size:, …) tokenised before `Identifier`. A named attribute added as
+          // a bare `word:` with no dedicated token would tokenise as
+          // `Identifier Colon` and be swallowed here instead of parsed as
+          // itself. Add a prefix token in tokens.ts for any new named attribute.
+          { ALT: () => this.SUBRULE(this.customAttr) }
+        ]);
+      }
+    });
+    this.CONSUME(RBracket);
+  });
+  // label: "..."
+  labelAttr = this.RULE("labelAttr", () => {
+    this.CONSUME(LabelPrefix);
+    this.CONSUME(StringLiteral, { LABEL: "labelValue" });
+  });
+  // expr: port="value", port2="value2"  (comma optional between assignments)
+  exprAttr = this.RULE("exprAttr", () => {
+    this.CONSUME(ExprPrefix);
+    this.SUBRULE(this.exprAssignment);
+    this.MANY(() => {
+      this.OPTION(() => this.CONSUME(Comma));
+      this.SUBRULE2(this.exprAssignment);
+    });
+  });
+  // port="value"
+  exprAssignment = this.RULE("exprAssignment", () => {
+    this.CONSUME(Identifier, { LABEL: "portName" });
+    this.CONSUME(Equals);
+    this.CONSUME(StringLiteral, { LABEL: "portValue" });
+  });
+  // portOrder: port=N,port=N
+  portOrderAttr = this.RULE("portOrderAttr", () => {
+    this.CONSUME(PortOrderPrefix);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.SUBRULE(this.portOrderAssignment);
+      }
+    });
+  });
+  // port=N
+  portOrderAssignment = this.RULE("portOrderAssignment", () => {
+    this.CONSUME(Identifier, { LABEL: "portName" });
+    this.CONSUME(Equals);
+    this.CONSUME(Integer, { LABEL: "orderValue" });
+  });
+  // portLabel: port="label",port2="label2"
+  portLabelAttr = this.RULE("portLabelAttr", () => {
+    this.CONSUME(PortLabelPrefix);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.SUBRULE(this.portLabelAssignment);
+      }
+    });
+  });
+  // port="label"
+  portLabelAssignment = this.RULE("portLabelAssignment", () => {
+    this.CONSUME(Identifier, { LABEL: "portName" });
+    this.CONSUME(Equals);
+    this.CONSUME(StringLiteral, { LABEL: "labelValue" });
+  });
+  // minimized
+  minimizedAttr = this.RULE("minimizedAttr", () => {
+    this.CONSUME(MinimizedKeyword);
+  });
+  // pullExecution: triggerPortName or true/false
+  pullExecutionAttr = this.RULE("pullExecutionAttr", () => {
+    this.CONSUME(PullExecutionPrefix);
+    this.CONSUME(Identifier, { LABEL: "pullValue" });
+  });
+  // size: width height
+  sizeAttr = this.RULE("sizeAttr", () => {
+    this.CONSUME(SizePrefix);
+    this.CONSUME(Integer, { LABEL: "widthValue" });
+    this.CONSUME2(Integer, { LABEL: "heightValue" });
+  });
+  // color: "value"
+  colorAttr = this.RULE("colorAttr", () => {
+    this.CONSUME(ColorPrefix);
+    this.CONSUME(StringLiteral, { LABEL: "colorValue" });
+  });
+  // icon: "value"
+  iconAttr = this.RULE("iconAttr", () => {
+    this.CONSUME(IconPrefix);
+    this.CONSUME(StringLiteral, { LABEL: "iconValue" });
+  });
+  // key: "value" — a generic bracket attribute a pack interprets. Matched last,
+  // so it never shadows a named attribute above.
+  customAttr = this.RULE("customAttr", () => {
+    this.CONSUME(Identifier, { LABEL: "attrKey" });
+    this.CONSUME(Colon);
+    this.CONSUME(StringLiteral, { LABEL: "attrValue" });
+  });
+  // tags: "label" "tooltip", "label2"
+  tagsAttr = this.RULE("tagsAttr", () => {
+    this.CONSUME(TagsPrefix);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.SUBRULE(this.tagEntry);
+      }
+    });
+  });
+  // suppress: "CODE", "CODE2"
+  suppressAttr = this.RULE("suppressAttr", () => {
+    this.CONSUME(SuppressPrefix);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.CONSUME(StringLiteral, { LABEL: "suppressCode" });
+      }
+    });
+  });
+  // "label" ["tooltip"]
+  tagEntry = this.RULE("tagEntry", () => {
+    this.CONSUME(StringLiteral, { LABEL: "tagLabel" });
+    this.OPTION(() => {
+      this.CONSUME2(StringLiteral, { LABEL: "tagTooltip" });
+    });
+  });
+};
+var parserInstance = new NodeParser();
+var BaseVisitor = parserInstance.getBaseCstVisitorConstructor();
+var NodeVisitor = class extends BaseVisitor {
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  nodeLine(ctx) {
+    const instanceId = ctx.instanceId[0].image;
+    const nodeType = ctx.nodeType[0].image;
+    let parentScope;
+    let label;
+    let expressions;
+    let portOrder;
+    let portLabel;
+    let minimized;
+    let pullExecution;
+    let size;
+    let color;
+    let icon;
+    let tags;
+    let attributes;
+    let suppress;
+    if (ctx.parentScopeRef) {
+      parentScope = this.visit(ctx.parentScopeRef);
+    }
+    if (ctx.attributeBracket) {
+      for (const bracket of ctx.attributeBracket) {
+        const attrs = this.visit(bracket);
+        if (attrs.label) label = attrs.label;
+        if (attrs.expressions) expressions = { ...expressions, ...attrs.expressions };
+        if (attrs.portOrder) portOrder = { ...portOrder, ...attrs.portOrder };
+        if (attrs.portLabel) portLabel = { ...portLabel, ...attrs.portLabel };
+        if (attrs.minimized) minimized = attrs.minimized;
+        if (attrs.pullExecution) pullExecution = attrs.pullExecution;
+        if (attrs.size) size = attrs.size;
+        if (attrs.color) color = attrs.color;
+        if (attrs.icon) icon = attrs.icon;
+        if (attrs.tags) tags = [...tags || [], ...attrs.tags];
+        if (attrs.attributes) attributes = { ...attributes || {}, ...attrs.attributes };
+        if (attrs.suppress) suppress = [...suppress || [], ...attrs.suppress];
+      }
+    }
+    return {
+      instanceId,
+      nodeType,
+      ...parentScope && { parentScope },
+      ...label && { label },
+      ...expressions && { expressions },
+      ...portOrder && { portOrder },
+      ...portLabel && { portLabel },
+      ...minimized && { minimized },
+      ...pullExecution && { pullExecution },
+      ...size && { size },
+      ...color && { color },
+      ...icon && { icon },
+      ...tags && { tags },
+      ...attributes && { attributes },
+      ...suppress && { suppress }
+    };
+  }
+  parentScopeRef(ctx) {
+    const parentNode = ctx.parentNode[0].image;
+    const scopeName = ctx.scopeName[0].image;
+    return `${parentNode}.${scopeName}`;
+  }
+  attributeBracket(ctx) {
+    let label;
+    let expressions;
+    let portOrder;
+    let portLabel;
+    let minimized;
+    let pullExecution;
+    let size;
+    let color;
+    let icon;
+    let tags;
+    let attributes;
+    let suppress;
+    if (ctx.labelAttr) {
+      for (const attr of ctx.labelAttr) {
+        label = this.visit(attr);
+      }
+    }
+    if (ctx.exprAttr) {
+      for (const attr of ctx.exprAttr) {
+        const exprs = this.visit(attr);
+        expressions = { ...expressions, ...exprs };
+      }
+    }
+    if (ctx.portOrderAttr) {
+      for (const attr of ctx.portOrderAttr) {
+        const orders = this.visit(attr);
+        portOrder = { ...portOrder, ...orders };
+      }
+    }
+    if (ctx.portLabelAttr) {
+      for (const attr of ctx.portLabelAttr) {
+        const labels = this.visit(attr);
+        portLabel = { ...portLabel, ...labels };
+      }
+    }
+    if (ctx.minimizedAttr) {
+      minimized = true;
+    }
+    if (ctx.pullExecutionAttr) {
+      for (const attr of ctx.pullExecutionAttr) {
+        pullExecution = this.visit(attr);
+      }
+    }
+    if (ctx.sizeAttr) {
+      for (const attr of ctx.sizeAttr) {
+        size = this.visit(attr);
+      }
+    }
+    if (ctx.colorAttr) {
+      for (const attr of ctx.colorAttr) {
+        color = this.visit(attr);
+      }
+    }
+    if (ctx.iconAttr) {
+      for (const attr of ctx.iconAttr) {
+        icon = this.visit(attr);
+      }
+    }
+    if (ctx.tagsAttr) {
+      for (const attr of ctx.tagsAttr) {
+        const parsed = this.visit(attr);
+        tags = [...tags || [], ...parsed];
+      }
+    }
+    if (ctx.customAttr) {
+      for (const attr of ctx.customAttr) {
+        const { key, value } = this.visit(attr);
+        attributes = { ...attributes || {}, [key]: value };
+      }
+    }
+    if (ctx.suppressAttr) {
+      for (const attr of ctx.suppressAttr) {
+        const codes = this.visit(attr);
+        suppress = [...suppress || [], ...codes];
+      }
+    }
+    return {
+      label,
+      expressions,
+      portOrder,
+      portLabel,
+      minimized,
+      pullExecution,
+      size,
+      color,
+      icon,
+      tags,
+      attributes,
+      suppress
+    };
+  }
+  labelAttr(ctx) {
+    return unquoteStringLiteral(ctx.labelValue[0].image);
+  }
+  exprAttr(ctx) {
+    const result = {};
+    if (ctx.exprAssignment) {
+      for (const assignment of ctx.exprAssignment) {
+        const { name, value } = this.visit(assignment);
+        result[name] = value;
+      }
+    }
+    return result;
+  }
+  exprAssignment(ctx) {
+    const name = ctx.portName[0].image;
+    const rawValue = ctx.portValue[0].image;
+    const value = unquoteStringLiteral(rawValue);
+    return { name, value };
+  }
+  portOrderAttr(ctx) {
+    const result = {};
+    if (ctx.portOrderAssignment) {
+      for (const assignment of ctx.portOrderAssignment) {
+        const { name, order } = this.visit(assignment);
+        result[name] = order;
+      }
+    }
+    return result;
+  }
+  portOrderAssignment(ctx) {
+    const name = ctx.portName[0].image;
+    const order = parseInt(ctx.orderValue[0].image, 10);
+    return { name, order };
+  }
+  portLabelAttr(ctx) {
+    const result = {};
+    if (ctx.portLabelAssignment) {
+      for (const assignment of ctx.portLabelAssignment) {
+        const { name, label } = this.visit(assignment);
+        result[name] = label;
+      }
+    }
+    return result;
+  }
+  portLabelAssignment(ctx) {
+    const name = ctx.portName[0].image;
+    const rawLabel = ctx.labelValue[0].image;
+    const label = unquoteStringLiteral(rawLabel);
+    return { name, label };
+  }
+  minimizedAttr() {
+    return true;
+  }
+  pullExecutionAttr(ctx) {
+    return ctx.pullValue[0].image;
+  }
+  sizeAttr(ctx) {
+    const width = parseInt(ctx.widthValue[0].image, 10);
+    const height = parseInt(ctx.heightValue[0].image, 10);
+    return { width, height };
+  }
+  colorAttr(ctx) {
+    return unquoteStringLiteral(ctx.colorValue[0].image);
+  }
+  iconAttr(ctx) {
+    return unquoteStringLiteral(ctx.iconValue[0].image);
+  }
+  customAttr(ctx) {
+    return {
+      key: ctx.attrKey[0].image,
+      value: unquoteStringLiteral(ctx.attrValue[0].image)
+    };
+  }
+  suppressAttr(ctx) {
+    return ctx.suppressCode.map((tok) => unquoteStringLiteral(tok.image));
+  }
+  tagsAttr(ctx) {
+    const result = [];
+    if (ctx.tagEntry) {
+      for (const entry of ctx.tagEntry) {
+        result.push(this.visit(entry));
+      }
+    }
+    return result;
+  }
+  tagEntry(ctx) {
+    const label = unquoteStringLiteral(ctx.tagLabel[0].image);
+    const tooltip = ctx.tagTooltip?.[0] ? unquoteStringLiteral(ctx.tagTooltip[0].image) : void 0;
+    return { label, ...tooltip && { tooltip } };
+  }
+};
+var visitorInstance = new NodeVisitor();
+function unquotedValueHint(input) {
+  const attribute = /\[\s*([A-Za-z][A-Za-z0-9]*)\s*:\s*([^\]"]+?)\s*\]/.exec(input);
+  if (!attribute) return null;
+  const [, name, rawValue] = attribute;
+  if (name === "expr") {
+    const binding = /^([A-Za-z_$][\w$]*)\s*=\s*(.+)$/.exec(rawValue);
+    if (!binding) return null;
+    const [, port, value] = binding;
+    const isReference = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)+$/.test(value);
+    const quoted = isReference ? `${port}="${value}"` : `${port}="'${value}'"`;
+    return `the [expr:] value for "${port}" is not quoted. An [expr:] value is JavaScript and the attribute itself takes a quoted string, so write [expr: ${quoted}].`;
+  }
+  return `the [${name}:] value is not quoted. Write [${name}: "${rawValue}"].`;
+}
+function parseNodeLine(input, warnings) {
+  const expected = "@node instanceId NodeType";
+  const tokens = lexTaggedLine(input, NodeTag, {
+    onLexError: (message) => {
+      warnings.push(lineFailure("node", input, message, expected, { verb: "tokenize" }));
+    }
+  });
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance, tokens, () => parserInstance.nodeLine());
+  if (error) {
+    warnings.push(lineFailure("node", input, unquotedValueHint(input) ?? error.message, expected));
+    return null;
+  }
+  return visitorInstance.visit(cst);
+}
+function getNodeGrammar() {
+  return parserInstance.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/connect-parser.ts
+var ConnectParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // Entry rule for connect line: @connect A.port -> B.port [as type]
+  connectLine = this.RULE("connectLine", () => {
+    this.CONSUME(ConnectTag);
+    this.SUBRULE(this.portRef, { LABEL: "sourceRef" });
+    this.CONSUME(Arrow);
+    this.SUBRULE2(this.portRef, { LABEL: "targetRef" });
+    this.OPTION(() => {
+      this.CONSUME(AsKeyword);
+      this.CONSUME(Identifier, { LABEL: "coerceType" });
+    });
+  });
+  // node.port, node.port:scope, or pseudo-node (secret:NAME)
+  portRef = this.RULE("portRef", () => {
+    this.CONSUME(Identifier, { LABEL: "nodeId" });
+    this.OR([
+      {
+        ALT: () => {
+          this.CONSUME(Dot);
+          this.CONSUME2(Identifier, { LABEL: "portName" });
+          this.OPTION(() => {
+            this.CONSUME(Colon);
+            this.CONSUME3(Identifier, { LABEL: "scopeName" });
+          });
+        }
+      },
+      {
+        // pseudo-node: secret:NAME (nodeId="secret", colon, pseudoName="NAME")
+        ALT: () => {
+          this.CONSUME2(Colon, { LABEL: "pseudoColon" });
+          this.CONSUME4(Identifier, { LABEL: "pseudoName" });
+        }
+      }
+    ]);
+  });
+};
+var parserInstance2 = new ConnectParser();
+var BaseVisitor2 = parserInstance2.getBaseCstVisitorConstructor();
+var ConnectVisitor = class extends BaseVisitor2 {
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  connectLine(ctx) {
+    const source = this.visit(ctx.sourceRef);
+    const target = this.visit(ctx.targetRef);
+    const result = { source, target };
+    if (ctx.coerceType?.[0]) {
+      const validTypes = /* @__PURE__ */ new Set(["string", "number", "boolean", "json", "object"]);
+      const raw = ctx.coerceType[0].image;
+      if (validTypes.has(raw)) {
+        result.coerce = raw;
+      } else {
+        result.invalidCoerceType = raw;
+      }
+    }
+    return result;
+  }
+  portRef(ctx) {
+    const nodeId = ctx.nodeId[0].image;
+    if (ctx.pseudoColon) {
+      const pseudoName = ctx.pseudoName[0].image;
+      return { nodeId: `${nodeId}:${pseudoName}`, portName: "value" };
+    }
+    const portName = ctx.portName[0].image;
+    const scope = ctx.scopeName?.[0]?.image;
+    return { nodeId, portName, scope };
+  }
+};
+var visitorInstance2 = new ConnectVisitor();
+function parseConnectLine(input, warnings) {
+  const tokens = lexTaggedLine(input, ConnectTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance2, tokens, () => parserInstance2.connectLine());
+  if (error) {
+    warnings.push(lineFailure("connect", input, error.message, "@connect sourceNode.port -> targetNode.port"));
+    return null;
+  }
+  const result = visitorInstance2.visit(cst);
+  if (result.invalidCoerceType) {
+    warnings.push(
+      `Invalid coerce type "${result.invalidCoerceType}" in @connect. Valid types: string, number, boolean, json, object`
+    );
+    delete result.invalidCoerceType;
+  }
+  return result;
+}
+function getConnectGrammar() {
+  return parserInstance2.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/scope-parser.ts
+var ScopeParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // Entry rule for scope line: @scope scopeName [child1, child2]
+  // or @scope container.scopeName [child1, child2]
+  scopeLine = this.RULE("scopeLine", () => {
+    this.CONSUME(ScopeTag);
+    this.SUBRULE(this.scopeRef);
+    this.CONSUME(LBracket);
+    this.AT_LEAST_ONE_SEP({
+      SEP: Comma,
+      DEF: () => {
+        this.CONSUME(Identifier, { LABEL: "childId" });
+      }
+    });
+    this.CONSUME(RBracket);
+  });
+  // scopeName or container.scopeName
+  scopeRef = this.RULE("scopeRef", () => {
+    this.CONSUME(Identifier, { LABEL: "firstPart" });
+    this.OPTION(() => {
+      this.CONSUME(Dot);
+      this.CONSUME2(Identifier, { LABEL: "secondPart" });
+    });
+  });
+};
+var parserInstance3 = new ScopeParser();
+var BaseVisitor3 = parserInstance3.getBaseCstVisitorConstructor();
+var ScopeVisitor = class extends BaseVisitor3 {
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  scopeLine(ctx) {
+    const scopeName = this.visit(ctx.scopeRef);
+    const children = ctx.childId.map((token) => token.image);
+    return { scopeName, children };
+  }
+  scopeRef(ctx) {
+    const firstPart = ctx.firstPart[0].image;
+    if (ctx.secondPart) {
+      const secondPart = ctx.secondPart[0].image;
+      return `${firstPart}.${secondPart}`;
+    }
+    return firstPart;
+  }
+};
+var visitorInstance3 = new ScopeVisitor();
+function parseScopeLine(input, warnings) {
+  const tokens = lexTaggedLine(input, ScopeTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance3, tokens, () => parserInstance3.scopeLine());
+  if (error) {
+    warnings.push(lineFailure("scope", input, error.message, "@scope scopeName [child1, child2]"));
+    return null;
+  }
+  return visitorInstance3.visit(cst);
+}
+function getScopeGrammar() {
+  return parserInstance3.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/path-parser.ts
+var PathParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // Entry rule: @path pathSequence (Comma pathSequence)*
+  pathLine = this.RULE("pathLine", () => {
+    this.CONSUME(PathTag);
+    this.SUBRULE(this.pathSequence, { LABEL: "firstSequence" });
+    this.MANY(() => {
+      this.CONSUME(Comma);
+      this.SUBRULE2(this.pathSequence, { LABEL: "nextSequence" });
+    });
+  });
+  // pathSequence: pathStep (Arrow pathStep)+
+  pathSequence = this.RULE("pathSequence", () => {
+    this.SUBRULE(this.pathStep, { LABEL: "firstStep" });
+    this.AT_LEAST_ONE(() => {
+      this.CONSUME(Arrow);
+      this.SUBRULE2(this.pathStep, { LABEL: "nextStep" });
+    });
+  });
+  // pathStep: Identifier (Colon Identifier)?
+  pathStep = this.RULE("pathStep", () => {
+    this.CONSUME(Identifier, { LABEL: "nodeName" });
+    this.OPTION(() => {
+      this.CONSUME(Colon);
+      this.CONSUME2(Identifier, { LABEL: "routeSuffix" });
+    });
+  });
+};
+var parserInstance4 = new PathParser();
+var BaseVisitor4 = parserInstance4.getBaseCstVisitorConstructor();
+var PathVisitor = class extends BaseVisitor4 {
+  warnings = [];
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  setWarnings(warnings) {
+    this.warnings = warnings;
+  }
+  pathLine(ctx) {
+    const results = [];
+    results.push(this.pathSequence(ctx.firstSequence[0].children));
+    if (ctx.nextSequence) {
+      for (const seqCst of ctx.nextSequence) {
+        results.push(this.pathSequence(seqCst.children));
+      }
+    }
+    return results;
+  }
+  pathSequence(ctx) {
+    const steps = [];
+    steps.push(this.pathStep(ctx.firstStep[0].children));
+    for (const stepCst of ctx.nextStep) {
+      steps.push(this.pathStep(stepCst.children));
+    }
+    return { steps };
+  }
+  pathStep(ctx) {
+    const node = ctx.nodeName[0].image;
+    let route;
+    if (ctx.routeSuffix && ctx.routeSuffix.length > 0) {
+      const suffix = ctx.routeSuffix[0].image;
+      if (suffix === "ok" || suffix === "fail") {
+        route = suffix;
+      } else {
+        this.warnings.push(
+          `@path: invalid route suffix ":${suffix}" on node "${node}". Expected ":ok" or ":fail", ignoring suffix.`
+        );
+      }
+    }
+    return route ? { node, route } : { node };
+  }
+};
+var visitorInstance4 = new PathVisitor();
+function parsePathLine(input, warnings) {
+  const tokens = lexTaggedLine(input, PathTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance4, tokens, () => parserInstance4.pathLine());
+  if (error) {
+    warnings.push(lineFailure("@path", input, error.message, "@path Start -> nodeA -> nodeB:ok -> Exit"));
+    return null;
+  }
+  visitorInstance4.setWarnings(warnings);
+  return visitorInstance4.visit(cst);
+}
+function getPathGrammar() {
+  return parserInstance4.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/map-parser.ts
+var MapParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // Entry rule: @map instanceId childNode[(inputPort -> outputPort)] over source.port
+  mapLine = this.RULE("mapLine", () => {
+    this.CONSUME(MapTag);
+    this.CONSUME(Identifier, { LABEL: "instanceId" });
+    this.CONSUME2(Identifier, { LABEL: "childId" });
+    this.OPTION(() => {
+      this.SUBRULE(this.portMapping);
+    });
+    this.CONSUME(OverKeyword);
+    this.SUBRULE(this.portRef);
+  });
+  // (inputPort -> outputPort)
+  portMapping = this.RULE("portMapping", () => {
+    this.CONSUME(LParen);
+    this.CONSUME(Identifier, { LABEL: "inputPort" });
+    this.CONSUME(Arrow);
+    this.CONSUME2(Identifier, { LABEL: "outputPort" });
+    this.CONSUME(RParen);
+  });
+  // node.port
+  portRef = this.RULE("portRef", () => {
+    this.CONSUME(Identifier, { LABEL: "sourceNode" });
+    this.CONSUME(Dot);
+    this.CONSUME2(Identifier, { LABEL: "sourcePort" });
+  });
+};
+var parserInstance5 = new MapParser();
+var BaseVisitor5 = parserInstance5.getBaseCstVisitorConstructor();
+var MapVisitor = class extends BaseVisitor5 {
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  mapLine(ctx) {
+    const instanceId = ctx.instanceId[0].image;
+    const childId = ctx.childId[0].image;
+    const portRef = this.visit(ctx.portRef[0]);
+    let inputPort;
+    let outputPort;
+    if (ctx.portMapping) {
+      const mapping = this.visit(ctx.portMapping[0]);
+      inputPort = mapping.inputPort;
+      outputPort = mapping.outputPort;
+    }
+    return {
+      instanceId,
+      childId,
+      sourceNode: portRef.sourceNode,
+      sourcePort: portRef.sourcePort,
+      ...inputPort && { inputPort },
+      ...outputPort && { outputPort }
+    };
+  }
+  portMapping(ctx) {
+    return {
+      inputPort: ctx.inputPort[0].image,
+      outputPort: ctx.outputPort[0].image
+    };
+  }
+  portRef(ctx) {
+    return {
+      sourceNode: ctx.sourceNode[0].image,
+      sourcePort: ctx.sourcePort[0].image
+    };
+  }
+};
+var visitorInstance5 = new MapVisitor();
+function parseMapLine(input, warnings) {
+  const tokens = lexTaggedLine(input, MapTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance5, tokens, () => parserInstance5.mapLine());
+  if (error) {
+    warnings.push(lineFailure("@map", input, error.message, "@map instanceId childNode over source.port"));
+    return null;
+  }
+  return visitorInstance5.visit(cst);
+}
+function getMapGrammar() {
+  return parserInstance5.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/trigger-cancel-parser.ts
+var CRON_ITEM = "(?:\\*|[0-9A-Za-z]+(?:-[0-9A-Za-z]+)?)(?:/\\d+)?";
+var CRON_FIELD = `${CRON_ITEM}(?:,${CRON_ITEM})*`;
+var CRON_REGEX = new RegExp(`^${CRON_FIELD}(?:\\s+${CRON_FIELD}){4}$`);
+function isValidCronExpression(expression) {
+  return CRON_REGEX.test(expression.trim());
+}
+var TriggerCancelParser = class extends CstParser {
+  constructor() {
+    super(allTokens);
+    this.performSelfAnalysis();
+  }
+  // @trigger event="agent/request" cron="0 9 * * *"
+  triggerLine = this.RULE("triggerLine", () => {
+    this.CONSUME(TriggerTag);
+    this.MANY(() => {
+      this.SUBRULE(this.assignment);
+    });
+  });
+  // @cancelOn event="app/user.deleted" match="data.userId" timeout="1h"
+  cancelOnLine = this.RULE("cancelOnLine", () => {
+    this.CONSUME(CancelOnTag);
+    this.AT_LEAST_ONE(() => {
+      this.SUBRULE(this.assignment);
+    });
+  });
+  // @retries 5
+  retriesLine = this.RULE("retriesLine", () => {
+    this.CONSUME(RetriesTag);
+    this.CONSUME(Integer, { LABEL: "retriesValue" });
+  });
+  // @timeout "30m"
+  timeoutLine = this.RULE("timeoutLine", () => {
+    this.CONSUME(TimeoutTag);
+    this.CONSUME(StringLiteral, { LABEL: "timeoutValue" });
+  });
+  // @throttle limit=3 period="1m"
+  throttleLine = this.RULE("throttleLine", () => {
+    this.CONSUME(ThrottleTag);
+    this.AT_LEAST_ONE(() => {
+      this.SUBRULE(this.assignment);
+    });
+  });
+  // key="value" or key=123
+  assignment = this.RULE("assignment", () => {
+    this.CONSUME(Identifier, { LABEL: "key" });
+    this.CONSUME(Equals);
+    this.OR([
+      { ALT: () => this.CONSUME(StringLiteral, { LABEL: "strValue" }) },
+      { ALT: () => this.CONSUME(Integer, { LABEL: "intValue" }) }
+    ]);
+  });
+};
+var parserInstance6 = new TriggerCancelParser();
+var BaseVisitor6 = parserInstance6.getBaseCstVisitorConstructor();
+var TRIGGER_KEYS = { event: "str", cron: "str" };
+var CANCEL_ON_KEYS = { event: "str", match: "str", timeout: "str" };
+var THROTTLE_KEYS = { limit: "int", period: "str" };
+var TriggerCancelVisitor = class extends BaseVisitor6 {
+  constructor() {
+    super();
+    this.validateVisitor();
+  }
+  collect(ctx, allowed) {
+    const result = { values: /* @__PURE__ */ new Map(), unknownKeys: [], badValues: [] };
+    for (const node of ctx.assignment ?? []) {
+      const a = this.visit(node);
+      const kind = allowed[a.key];
+      if (kind === void 0) {
+        result.unknownKeys.push(a.key);
+        continue;
+      }
+      if (kind === "str" && a.str === void 0 || kind === "int" && a.int === void 0) {
+        result.badValues.push(a.key);
+        continue;
+      }
+      result.values.set(a.key, a);
+    }
+    return result;
+  }
+  triggerLine(ctx) {
+    return this.collect(ctx, TRIGGER_KEYS);
+  }
+  cancelOnLine(ctx) {
+    return this.collect(ctx, CANCEL_ON_KEYS);
+  }
+  throttleLine(ctx) {
+    return this.collect(ctx, THROTTLE_KEYS);
+  }
+  assignment(ctx) {
+    const key = ctx.key[0].image;
+    if (ctx.strValue?.[0]) {
+      return { key, str: unquoteStringLiteral(ctx.strValue[0].image) };
+    }
+    return { key, int: parseInt(ctx.intValue[0].image, 10) };
+  }
+  retriesLine(ctx) {
+    return { retries: parseInt(ctx.retriesValue[0].image, 10) };
+  }
+  timeoutLine(ctx) {
+    return { timeout: unquoteStringLiteral(ctx.timeoutValue[0].image) };
+  }
+};
+var visitorInstance6 = new TriggerCancelVisitor();
+function parseTriggerLine(input, warnings) {
+  const tokens = lexTaggedLine(input, TriggerTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance6, tokens, () => parserInstance6.triggerLine());
+  if (error) {
+    return null;
+  }
+  const options = visitorInstance6.visit(cst);
+  if (options.values.size === 0 || options.unknownKeys.length > 0 || options.badValues.length > 0) {
+    return null;
+  }
+  const result = {};
+  const event = options.values.get("event");
+  if (event) result.event = event.str;
+  const cron = options.values.get("cron");
+  if (cron) result.cron = cron.str;
+  if (result.cron && !isValidCronExpression(result.cron)) {
+    warnings.push(`Invalid cron expression: "${result.cron}". Expected 5 fields (minute hour day month weekday).`);
+  }
+  return result;
+}
+function parseCancelOnLine(input, warnings) {
+  const tokens = lexTaggedLine(input, CancelOnTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance6, tokens, () => parserInstance6.cancelOnLine());
+  const expected = '@cancelOn event="name" match="field" timeout="duration"';
+  if (error) {
+    warnings.push(lineFailure("cancelOn", input, error.message, expected));
+    return null;
+  }
+  const options = visitorInstance6.visit(cst);
+  const problem = options.unknownKeys.length > 0 ? `unknown option "${options.unknownKeys[0]}"` : options.badValues.length > 0 ? `"${options.badValues[0]}" takes a quoted string` : !options.values.has("event") ? 'event="name" is required' : null;
+  if (problem) {
+    warnings.push(lineFailure("cancelOn", input, problem, expected));
+    return null;
+  }
+  const result = { event: options.values.get("event").str };
+  const match = options.values.get("match");
+  if (match) result.match = match.str;
+  const timeout = options.values.get("timeout");
+  if (timeout) result.timeout = timeout.str;
+  return result;
+}
+function parseRetriesLine(input, warnings) {
+  const tokens = lexTaggedLine(input, RetriesTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance6, tokens, () => parserInstance6.retriesLine());
+  if (error) {
+    warnings.push(lineFailure("retries", input, error.message, "@retries <integer>"));
+    return null;
+  }
+  const result = visitorInstance6.visit(cst);
+  if (result.retries < 0) {
+    warnings.push(`Invalid @retries value: ${result.retries}. Expected non-negative integer.`);
+  }
+  return result;
+}
+function parseTimeoutLine(input, warnings) {
+  const tokens = lexTaggedLine(input, TimeoutTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance6, tokens, () => parserInstance6.timeoutLine());
+  if (error) {
+    warnings.push(lineFailure("timeout", input, error.message, '@timeout "duration"'));
+    return null;
+  }
+  return visitorInstance6.visit(cst);
+}
+function parseThrottleLine(input, warnings) {
+  const tokens = lexTaggedLine(input, ThrottleTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance6, tokens, () => parserInstance6.throttleLine());
+  const expected = '@throttle limit=<number> period="duration"';
+  if (error) {
+    warnings.push(lineFailure("throttle", input, error.message, expected));
+    return null;
+  }
+  const options = visitorInstance6.visit(cst);
+  const problem = options.unknownKeys.length > 0 ? `unknown option "${options.unknownKeys[0]}"` : options.badValues.length > 0 ? options.badValues[0] === "limit" ? "limit takes an integer" : `"${options.badValues[0]}" takes a quoted string` : !options.values.has("limit") ? "limit=<number> is required" : null;
+  if (problem) {
+    warnings.push(lineFailure("throttle", input, problem, expected));
+    return null;
+  }
+  const result = { limit: options.values.get("limit").int };
+  const period = options.values.get("period");
+  if (period) result.period = period.str;
+  return result;
+}
+function getTriggerCancelGrammar() {
+  return parserInstance6.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/fan-parser.ts
+var FanParser = class 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" });
+    });
+  });
+};
+var parserInstance7 = new FanParser();
+var BaseVisitor7 = parserInstance7.getBaseCstVisitorConstructor();
+var FanVisitor = class extends BaseVisitor7 {
+  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 };
+  }
+};
+var visitorInstance7 = new FanVisitor();
+function parseFanOutLine(input, warnings) {
+  const tokens = lexTaggedLine(input, FanOutTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance7, tokens, () => parserInstance7.fanOutLine());
+  if (error) {
+    warnings.push(
+      lineFailure("@fanOut", input, error.message, "@fanOut source.port -> target1, target2, target3", {
+        maxLength: 80
+      })
+    );
+    return null;
+  }
+  return visitorInstance7.visit(cst);
+}
+function parseFanInLine(input, warnings) {
+  const tokens = lexTaggedLine(input, FanInTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance7, tokens, () => parserInstance7.fanInLine());
+  if (error) {
+    warnings.push(
+      lineFailure("@fanIn", input, error.message, "@fanIn source1.port, source2.port -> target.port", {
+        maxLength: 80
+      })
+    );
+    return null;
+  }
+  return visitorInstance7.visit(cst);
+}
+function getFanGrammar() {
+  return parserInstance7.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/coerce-parser.ts
+var VALID_COERCE_TYPES = /* @__PURE__ */ new Set(["string", "number", "boolean", "json", "object"]);
+var CoerceParser = class 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" });
+  });
+};
+var parserInstance8 = new CoerceParser();
+var BaseVisitor8 = parserInstance8.getBaseCstVisitorConstructor();
+var CoerceVisitor = class extends BaseVisitor8 {
+  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
+    };
+  }
+};
+var visitorInstance8 = new CoerceVisitor();
+function parseCoerceLine(input, warnings) {
+  const tokens = lexTaggedLine(input, CoerceTag);
+  if (!tokens) return null;
+  const { cst, error } = runRule(parserInstance8, tokens, () => parserInstance8.coerceLine());
+  if (error) {
+    warnings.push(
+      lineFailure("@coerce", input, error.message, "@coerce instanceId source.port -> target.port as type", {
+        maxLength: 80
+      })
+    );
+    return null;
+  }
+  const result = visitorInstance8.visit(cst);
+  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;
+}
+function getCoerceGrammar() {
+  return parserInstance8.getSerializedGastProductions();
+}
+
+// src/chevrotain-parser/grammar-diagrams.ts
+function serializedToEBNF(productions) {
+  const lines = [];
+  for (const prod of productions) {
+    if (prod.type === "Rule") {
+      const rule = prod;
+      if (rule.definition && rule.name) {
+        const body = definitionToEBNF(rule.definition);
+        lines.push(`${rule.name} ::= ${body}`);
+      }
+    }
+  }
+  return lines.join("\n\n");
+}
+function definitionToEBNF(definition) {
+  return definition.map((item) => itemToEBNF(item)).join(" ");
+}
+function itemToEBNF(item) {
+  switch (item.type) {
+    case "Terminal": {
+      const pattern = item.pattern || "";
+      if (pattern.startsWith("@")) {
+        return `"${pattern.replace("\\b", "")}"`;
+      }
+      const punctuation = {
+        "->": '"->"',
+        ":": '":"',
+        ",": '","',
+        "=": '"="',
+        "-": '"-"',
+        "\\.": '"."',
+        "\\[": '"["',
+        "\\]": '"]"',
+        "\\(": '"("',
+        "\\)": '")"'
+      };
+      if (punctuation[pattern]) return punctuation[pattern];
+      if (pattern === "scope:") return '"scope:"';
+      if (pattern === "order:") return '"order:"';
+      if (pattern === "placement:") return '"placement:"';
+      if (pattern === "label:") return '"label:"';
+      if (pattern === "expr:") return '"expr:"';
+      if (pattern === "portOrder:") return '"portOrder:"';
+      if (pattern === "pullExecution:") return '"pullExecution:"';
+      if (pattern === "minimized\\b") return '"minimized"';
+      if (pattern === "TOP\\b") return '"TOP"';
+      if (pattern === "BOTTOM\\b") return '"BOTTOM"';
+      if (pattern === "[a-zA-Z_$][a-zA-Z0-9_$]*" || pattern === "[a-zA-Z_$][a-zA-Z0-9_$\\/-]*" || pattern === "[a-zA-Z_$](?:[a-zA-Z0-9_$\\/]|-(?!>))*") {
+        const semanticName = item.terminalLabel || "IDENTIFIER";
+        return semanticName;
+      }
+      if (pattern === "-?\\d+") {
+        return item.terminalLabel || "INTEGER";
+      }
+      if (pattern.includes('(?:[^"\\\\]|\\\\.)*')) {
+        return item.terminalLabel || "STRING";
+      }
+      return item.terminalLabel || item.name || "unknown";
+    }
+    case "NonTerminal":
+      return `<${item.name || "unknown"}>`;
+    case "Alternation": {
+      const alts = (item.definition || []).map((alt) => {
+        if (alt.type === "Alternative" && alt.definition) {
+          return definitionToEBNF(alt.definition);
+        }
+        return itemToEBNF(alt);
+      });
+      return `( ${alts.join(" | ")} )`;
+    }
+    case "Option":
+      return `[ ${definitionToEBNF(item.definition || [])} ]`;
+    case "Repetition":
+      return `{ ${definitionToEBNF(item.definition || [])} }`;
+    case "RepetitionMandatory":
+      return `${definitionToEBNF(item.definition || [])}+`;
+    case "RepetitionMandatoryWithSeparator": {
+      const sepName = item.separator?.name || ",";
+      return `${definitionToEBNF(item.definition || [])} { "${sepName === "Comma" ? "," : sepName}" ${definitionToEBNF(item.definition || [])} }`;
+    }
+    case "RepetitionWithSeparator": {
+      const sep = item.separator?.name || ",";
+      return `[ ${definitionToEBNF(item.definition || [])} { "${sep === "Comma" ? "," : sep}" ${definitionToEBNF(item.definition || [])} } ]`;
+    }
+    default:
+      return `/* ${item.type} */`;
+  }
+}
+function getAllGrammars() {
+  return {
+    port: getPortGrammar(),
+    node: getNodeGrammar(),
+    connect: getConnectGrammar(),
+    scope: getScopeGrammar(),
+    path: getPathGrammar(),
+    map: getMapGrammar(),
+    fan: getFanGrammar(),
+    coerce: getCoerceGrammar(),
+    triggerCancel: getTriggerCancelGrammar()
+  };
+}
+function generateGrammarDiagrams() {
+  const grammars = getAllGrammars();
+  const allProductions = [
+    ...grammars.port,
+    ...grammars.node,
+    ...grammars.connect,
+    ...grammars.scope,
+    ...grammars.path,
+    ...grammars.map,
+    ...grammars.fan,
+    ...grammars.coerce,
+    ...grammars.triggerCancel
+  ];
+  const html = createSyntaxDiagramsCode(allProductions);
+  const ebnf = serializedToEBNF(allProductions);
+  const customStyles = `
+<style>
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 2rem;
+    background-color: #f8f9fa !important;
+  }
+  h1.grammar-title {
+    text-align: center;
+    color: #333;
+    margin-bottom: 0.5rem;
+    font-size: 2rem;
+  }
+  .back-link {
+    display: block;
+    text-align: center;
+    margin-bottom: 2rem;
+    color: #4a90d9;
+    text-decoration: none;
+  }
+  .back-link:hover { text-decoration: underline; }
+  .tabs {
+    display: flex;
+    gap: 0;
+    margin-bottom: 0;
+    border-bottom: 2px solid #ddd;
+  }
+  .tab {
+    padding: 0.75rem 1.5rem;
+    cursor: pointer;
+    background: #e9ecef;
+    border: none;
+    border-bottom: 2px solid transparent;
+    margin-bottom: -2px;
+    font-size: 1rem;
+    color: #666;
+  }
+  .tab:hover { background: #dee2e6; }
+  .tab.active {
+    background: #fff;
+    border-bottom-color: #4a90d9;
+    color: #333;
+    font-weight: 500;
+  }
+  .tab-content { display: none; padding: 1rem 0; }
+  .tab-content.active { display: block; }
+  .ebnf-container {
+    background: #1e1e1e;
+    color: #d4d4d4;
+    padding: 1.5rem;
+    border-radius: 8px;
+    overflow-x: auto;
+    font-family: 'Fira Code', 'Consolas', monospace;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    white-space: pre-wrap;
+  }
+  .ebnf-container .rule-name { color: #569cd6; }
+  .ebnf-container .terminal { color: #ce9178; }
+  .ebnf-container .nonterminal { color: #4ec9b0; }
+  .ebnf-container .operator { color: #d4d4d4; }
+</style>
+`;
+  const escaped = ebnf.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const ebnfHtml = escaped.replace(/"([^"]+)"/g, "___TERM_START___$1___TERM_END___").replace(/&lt;(\w+)&gt;/g, "___NT_START___$1___NT_END___").replace(/^(\w+)\s*::=/gm, "___RULE_START___$1___RULE_END___ ::=").replace(/___TERM_START___/g, '<span class="terminal">"').replace(/___TERM_END___/g, '"</span>').replace(/___NT_START___/g, '<span class="nonterminal">&lt;').replace(/___NT_END___/g, "&gt;</span>").replace(/___RULE_START___/g, '<span class="rule-name">').replace(/___RULE_END___/g, "</span>");
+  const header = `
+<h1 class="grammar-title">Flow Weaver JSDoc Grammar</h1>
+<a href="index.html" class="back-link">\u2190 Back to API Documentation</a>
+<div class="tabs">
+  <button class="tab active" onclick="showTab('diagrams')">Railroad Diagrams</button>
+  <button class="tab" onclick="showTab('ebnf')">EBNF Text</button>
+</div>
+<div id="ebnf" class="tab-content">
+  <div class="ebnf-container">${ebnfHtml}</div>
+</div>
+<script>
+function showTab(id) {
+  document.querySelectorAll('.tab-content').forEach(el => el.classList.remove('active'));document.querySelectorAll('.tab').forEach(el => el.classList.remove('active'));document.getElementById(id).classList.add('active');event.target.classList.add('active');
+}
+</script>
+`;
+  return html.replace("</style>", `</style>${customStyles}`).replace('<div id="diagrams"', `${header}<div id="diagrams" class="tab-content active"`);
+}
+function generateGrammarDiagramFor(grammarName) {
+  const grammars = getAllGrammars();
+  const grammar = grammars[grammarName];
+  const html = createSyntaxDiagramsCode(grammar);
+  const title = grammarName.charAt(0).toUpperCase() + grammarName.slice(1);
+  const header = `<h1 style="text-align:center;color:#333">${title} Grammar</h1>`;
+  return html.replace('<div id="diagrams"', `${header}<div id="diagrams"`);
+}
+
+export {
+  parseNodeLine,
+  parseConnectLine,
+  parseScopeLine,
+  parseMapLine,
+  parsePathLine,
+  parseFanOutLine,
+  parseFanInLine,
+  parseCoerceLine,
+  parseTriggerLine,
+  parseCancelOnLine,
+  parseRetriesLine,
+  parseTimeoutLine,
+  parseThrottleLine,
+  serializedToEBNF,
+  getAllGrammars,
+  generateGrammarDiagrams,
+  generateGrammarDiagramFor
+};