@probelabs/probe 0.6.0-rc118 → 0.6.0-rc120

package/cjs/index.cjs

@@ -42864,7 +42864,7 @@ function tokenize(text) {
   const lexResult = MermaidLexer.tokenize(text);
   return lexResult;
 }
-var Identifier, NumberLiteral, FlowchartKeyword, GraphKeyword, Direction, SubgraphKeyword, EndKeyword, ClassKeyword, StyleKeyword, ClassDefKeyword, Ampersand, Comma, Semicolon, Colon, TripleColon, BiDirectionalArrow, CircleEndLine, CrossEndLine, DottedArrowRight, DottedArrowLeft, ThickArrowRight, ThickArrowLeft, ArrowRight, ArrowLeft, DottedLine, ThickLine, Line, TwoDashes, InvalidArrow, DoubleSquareOpen, DoubleSquareClose, DoubleRoundOpen, DoubleRoundClose, HexagonOpen, HexagonClose, StadiumOpen, StadiumClose, CylinderOpen, CylinderClose, SquareOpen, SquareClose, RoundOpen, RoundClose, DiamondOpen, DiamondClose, AngleOpen, AngleLess, Pipe, ForwardSlash, Backslash, QuotedString, MultilineText, Comment, ColorValue, Text, WhiteSpace, Newline, allTokens, MermaidLexer;
+var Identifier, NumberLiteral, FlowchartKeyword, GraphKeyword, Direction, SubgraphKeyword, EndKeyword, ClassKeyword, StyleKeyword, ClassDefKeyword, ClickKeyword, LinkStyleKeyword, Ampersand, Comma, Semicolon, Colon, TripleColon, BiDirectionalArrow, CircleEndLine, CrossEndLine, DottedArrowRight, DottedArrowLeft, ThickArrowRight, ThickArrowLeft, ArrowRight, ArrowLeft, DottedLine, ThickLine, Line, TwoDashes, InvalidArrow, DoubleSquareOpen, DoubleSquareClose, DoubleRoundOpen, DoubleRoundClose, HexagonOpen, HexagonClose, StadiumOpen, StadiumClose, CylinderOpen, CylinderClose, SquareOpen, SquareClose, RoundOpen, RoundClose, DiamondOpen, DiamondClose, AngleOpen, AngleLess, AtSign, Pipe, ForwardSlash, Backslash, QuotedString, MultilineText, Comment, ColorValue, Text, WhiteSpace, Newline, allTokens, MermaidLexer;
 var init_lexer2 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/flowchart/lexer.js"() {
     init_api5();
@@ -42917,6 +42917,8 @@ var init_lexer2 = __esm({
       pattern: /classDef/,
       longer_alt: Identifier
     });
+    ClickKeyword = createToken({ name: "ClickKeyword", pattern: /click/, longer_alt: Identifier });
+    LinkStyleKeyword = createToken({ name: "LinkStyleKeyword", pattern: /linkStyle/, longer_alt: Identifier });
     Ampersand = createToken({
       name: "Ampersand",
       pattern: /&/
@@ -43011,6 +43013,7 @@ var init_lexer2 = __esm({
     DiamondClose = createToken({ name: "DiamondClose", pattern: /\}/ });
     AngleOpen = createToken({ name: "AngleOpen", pattern: />/ });
     AngleLess = createToken({ name: "AngleLess", pattern: /</ });
+    AtSign = createToken({ name: "AtSign", pattern: /@/ });
     Pipe = createToken({ name: "Pipe", pattern: /\|/ });
     ForwardSlash = createToken({ name: "ForwardSlash", pattern: /\// });
     Backslash = createToken({ name: "Backslash", pattern: /\\/ });
@@ -43061,6 +43064,8 @@ var init_lexer2 = __esm({
       ClassDefKeyword,
       ClassKeyword,
       StyleKeyword,
+      ClickKeyword,
+      LinkStyleKeyword,
       Direction,
       // Special multi-char brackets before arrows (some contain > or -)
       DoubleSquareOpen,
@@ -43097,6 +43102,7 @@ var init_lexer2 = __esm({
       DiamondClose,
       AngleOpen,
       AngleLess,
+      AtSign,
       ForwardSlash,
       Backslash,
       Pipe,
@@ -43153,9 +43159,12 @@ var init_parser2 = __esm({
           this.OR([
             { ALT: () => this.SUBRULE(this.nodeStatement) },
             { ALT: () => this.SUBRULE(this.subgraph) },
+            { ALT: () => this.SUBRULE(this.directionStatement) },
             { ALT: () => this.SUBRULE(this.classStatement) },
             { ALT: () => this.SUBRULE(this.styleStatement) },
             { ALT: () => this.SUBRULE(this.classDefStatement) },
+            { ALT: () => this.SUBRULE(this.clickStatement) },
+            { ALT: () => this.SUBRULE(this.linkStyleStatement) },
             { ALT: () => this.CONSUME(Newline) }
             // Empty lines
           ]);
@@ -43191,6 +43200,7 @@ var init_parser2 = __esm({
                 this.OPTION(() => {
                   this.CONSUME(NumberLiteral, { LABEL: "nodeIdSuffix" });
                 });
+                this.OPTION1(() => this.SUBRULE(this.attrObject));
               }
             },
             {
@@ -43207,6 +43217,146 @@ var init_parser2 = __esm({
             this.CONSUME3(Identifier, { LABEL: "nodeClass" });
           });
         });
+        this.attrObject = this.RULE("attrObject", () => {
+          this.CONSUME(AtSign);
+          this.CONSUME(DiamondOpen, { LABEL: "attrLCurly" });
+          this.OPTION(() => {
+            this.SUBRULE(this.attrPair);
+            this.MANY(() => {
+              this.CONSUME(Comma);
+              this.SUBRULE2(this.attrPair);
+            });
+          });
+          this.CONSUME(DiamondClose, { LABEL: "attrRCurly" });
+        });
+        this.attrPair = this.RULE("attrPair", () => {
+          this.CONSUME(Identifier, { LABEL: "attrKey" });
+          this.CONSUME(Colon);
+          this.OR([
+            {
+              GATE: () => {
+                const prev = this.LA(-1);
+                const keyTok = this.LA(-2);
+                return keyTok && /^(shape)$/i.test(String(keyTok.image || ""));
+              },
+              ALT: () => this.SUBRULE(this.attrShapeValue)
+            },
+            { ALT: () => this.CONSUME(QuotedString) },
+            { ALT: () => this.CONSUME2(Identifier) },
+            { ALT: () => this.CONSUME(NumberLiteral) },
+            { ALT: () => this.CONSUME(Text) }
+          ]);
+        });
+        this.attrShapeValue = this.RULE("attrShapeValue", () => {
+          const isKnownShapeId = () => {
+            const la = this.LA(1);
+            if (!la || la.tokenType !== Identifier)
+              return false;
+            const v3 = String(la.image || "").toLowerCase();
+            return v3 === "rect" || v3 === "round" || v3 === "rounded" || v3 === "stadium" || v3 === "subroutine" || v3 === "circle" || v3 === "cylinder" || v3 === "diamond" || v3 === "trapezoid" || v3 === "trapezoidalt" || v3 === "parallelogram" || v3 === "hexagon" || v3 === "lean-l" || v3 === "lean-r" || v3 === "icon" || v3 === "image";
+          };
+          const isKnownShapeQuoted = () => {
+            const la = this.LA(1);
+            if (!la || la.tokenType !== QuotedString)
+              return false;
+            const raw = String(la.image || "");
+            const unq = raw.length >= 2 && (raw.startsWith('"') || raw.startsWith("'")) ? raw.slice(1, -1) : raw;
+            const v3 = unq.toLowerCase();
+            return v3 === "rect" || v3 === "round" || v3 === "rounded" || v3 === "stadium" || v3 === "subroutine" || v3 === "circle" || v3 === "cylinder" || v3 === "diamond" || v3 === "trapezoid" || v3 === "trapezoidalt" || v3 === "parallelogram" || v3 === "hexagon" || v3 === "lean-l" || v3 === "lean-r" || v3 === "icon" || v3 === "image";
+          };
+          this.OR([
+            { GATE: isKnownShapeId, ALT: () => this.CONSUME(Identifier, { LABEL: "shapeId" }) },
+            { GATE: isKnownShapeQuoted, ALT: () => this.CONSUME(QuotedString, { LABEL: "shapeQuoted" }) },
+            // Fallback: accept any identifier/quoted/number/text so parse continues; semantics will flag unknowns
+            { ALT: () => this.CONSUME2(Identifier) },
+            { ALT: () => this.CONSUME2(QuotedString) },
+            { ALT: () => this.CONSUME(NumberLiteral) },
+            { ALT: () => this.CONSUME(Text) }
+          ]);
+        });
+        this.clickStatement = this.RULE("clickStatement", () => {
+          this.CONSUME(ClickKeyword);
+          this.CONSUME(Identifier, { LABEL: "clickTarget" });
+          this.OR([
+            {
+              GATE: () => this.LA(1).tokenType === Identifier && /^(href)$/i.test(this.LA(1).image || ""),
+              ALT: () => this.SUBRULE(this.clickHref)
+            },
+            {
+              GATE: () => this.LA(1).tokenType === Identifier && /^(call|callback)$/i.test(this.LA(1).image || ""),
+              ALT: () => this.SUBRULE(this.clickCall)
+            }
+          ]);
+          this.OPTION(() => this.CONSUME(Newline));
+        });
+        this.clickHref = this.RULE("clickHref", () => {
+          this.CONSUME(Identifier, { LABEL: "mode" });
+          this.CONSUME(QuotedString, { LABEL: "url" });
+          this.OPTION(() => this.CONSUME2(QuotedString, { LABEL: "tooltip" }));
+          this.OPTION2(() => this.CONSUME2(Identifier, { LABEL: "target" }));
+        });
+        this.clickCall = this.RULE("clickCall", () => {
+          this.CONSUME1(Identifier, { LABEL: "mode" });
+          this.OPTION1(() => {
+            this.CONSUME2(Identifier, { LABEL: "fn" });
+            this.OPTION2(() => {
+              this.CONSUME3(RoundOpen);
+              this.OPTION3(() => {
+                this.OR([
+                  { ALT: () => this.CONSUME4(Identifier) },
+                  { ALT: () => this.CONSUME5(NumberLiteral) },
+                  { ALT: () => this.CONSUME6(Text) }
+                ]);
+              });
+              this.CONSUME7(RoundClose);
+            });
+          });
+          this.OPTION4(() => this.CONSUME8(QuotedString, { LABEL: "tooltip" }));
+        });
+        this.linkStyleStatement = this.RULE("linkStyleStatement", () => {
+          this.CONSUME(LinkStyleKeyword);
+          this.SUBRULE(this.linkStyleIndexList);
+          this.OPTION1(() => this.CONSUME1(Newline));
+          this.SUBRULE(this.linkStylePairs);
+          this.OPTION2(() => this.CONSUME2(Newline));
+        });
+        this.linkStyleIndexList = this.RULE("linkStyleIndexList", () => {
+          this.CONSUME(NumberLiteral, { LABEL: "index" });
+          this.MANY(() => {
+            this.CONSUME(Comma);
+            this.CONSUME2(NumberLiteral, { LABEL: "index" });
+          });
+        });
+        this.linkStylePairs = this.RULE("linkStylePairs", () => {
+          this.SUBRULE(this.linkStylePair);
+          this.MANY(() => {
+            this.CONSUME(Comma);
+            this.OPTION(() => this.CONSUME(Newline));
+            this.SUBRULE2(this.linkStylePair);
+          });
+        });
+        this.linkStylePair = this.RULE("linkStylePair", () => {
+          this.CONSUME1(Identifier, { LABEL: "key" });
+          this.CONSUME(Colon);
+          this.SUBRULE(this.linkStyleValueChunk);
+        });
+        this.linkStyleValueChunk = this.RULE("linkStyleValueChunk", () => {
+          this.AT_LEAST_ONE({
+            GATE: () => {
+              const la = this.LA(1);
+              return la && la.tokenType !== Comma && la.tokenType !== Newline;
+            },
+            DEF: () => {
+              this.OR([
+                { ALT: () => this.CONSUME(ColorValue) },
+                { ALT: () => this.CONSUME(QuotedString) },
+                { ALT: () => this.CONSUME(NumberLiteral) },
+                { ALT: () => this.CONSUME(Identifier) },
+                { ALT: () => this.CONSUME(Text) }
+              ]);
+            }
+          });
+        });
         this.nodeShape = this.RULE("nodeShape", () => {
           this.OR([
             // Square brackets: [text]
@@ -43310,6 +43460,10 @@ var init_parser2 = __esm({
           ]);
         });
         this.link = this.RULE("link", () => {
+          this.OPTION1(() => {
+            this.CONSUME(Identifier, { LABEL: "edgeId" });
+            this.CONSUME(AtSign);
+          });
           this.OR([
             // Arrows with inline text (e.g., -.text.-> or ==text==>)
             {
@@ -43350,7 +43504,7 @@ var init_parser2 = __esm({
             { ALT: () => this.CONSUME(InvalidArrow) }
             // Capture for error
           ]);
-          this.OPTION(() => {
+          this.OPTION2(() => {
             this.CONSUME(Pipe);
             this.SUBRULE(this.linkText);
             this.CONSUME2(Pipe);
@@ -43512,26 +43666,66 @@ var init_parser2 = __esm({
 // node_modules/@probelabs/maid/out/diagrams/flowchart/semantics.js
 function analyzeFlowchart(cst, _tokens, opts) {
   const ctx = { errors: [], strict: opts?.strict };
-  const v3 = new FlowSemanticsVisitor(ctx);
+  const collector = new NodeIdCollector();
+  collector.visit(cst);
+  const v3 = new FlowSemanticsVisitor(ctx, collector.ids, collector.edgeIds);
   v3.visit(cst);
   return ctx.errors;
 }
-var BaseVisitor, FlowSemanticsVisitor;
+var BaseVisitor, FlowSemanticsVisitor, NodeIdCollector;
 var init_semantics = __esm({
   "node_modules/@probelabs/maid/out/diagrams/flowchart/semantics.js"() {
     init_parser2();
     BaseVisitor = parserInstance.getBaseCstVisitorConstructorWithDefaults();
     FlowSemanticsVisitor = class extends BaseVisitor {
-      constructor(ctx) {
+      constructor(ctx, knownIds, knownEdgeIds) {
         super();
+        this.edgeCount = 0;
         this.validateVisitor();
         this.ctx = ctx;
+        this.knownIds = knownIds;
+        this.knownEdgeIds = knownEdgeIds;
       }
       // Entry point
       diagram(ctx) {
         if (ctx.statement)
           ctx.statement.forEach((s3) => this.visit(s3));
       }
+      classStatement(ctx) {
+        const ids = ctx.Identifier || [];
+        const classNameTok = ctx.className && ctx.className[0];
+        for (const idTok of ids) {
+          if (classNameTok && idTok.startOffset === classNameTok.startOffset)
+            continue;
+          const id = String(idTok.image);
+          if (!(this.knownIds.has(id) || this.knownEdgeIds.has(id))) {
+            this.ctx.errors.push({
+              line: idTok.startLine ?? 1,
+              column: idTok.startColumn ?? 1,
+              severity: "warning",
+              code: "FL-CLASS-TARGET-UNKNOWN",
+              message: `Unknown id '${id}' in class statement.`,
+              hint: "Define the node/link before applying classes, or move the class line after it."
+            });
+          }
+        }
+      }
+      styleStatement(ctx) {
+        const idTok = ctx.Identifier && ctx.Identifier[0];
+        if (idTok) {
+          const id = String(idTok.image);
+          if (!this.knownIds.has(id)) {
+            this.ctx.errors.push({
+              line: idTok.startLine ?? 1,
+              column: idTok.startColumn ?? 1,
+              severity: "warning",
+              code: "FL-STYLE-TARGET-UNKNOWN",
+              message: `Unknown node id '${id}' in style statement.`,
+              hint: "Define the node before styling it, or move the style line after the node definition."
+            });
+          }
+        }
+      }
       statement(ctx) {
         for (const k3 of Object.keys(ctx)) {
           const arr = ctx[k3];
@@ -43543,6 +43737,141 @@ var init_semantics = __esm({
           }
         }
       }
+      clickStatement(ctx) {
+        const href = ctx.clickHref?.[0];
+        const call = !href ? ctx.clickCall?.[0] : void 0;
+        if (href) {
+          const ch = href.children || {};
+          const modeTok2 = ch.mode?.[0];
+          const urlTok = ch.url?.[0];
+          const tipTok = ch.tooltip?.[0];
+          const tgtTok = ch.target?.[0];
+          const mode2 = String(modeTok2?.image || "").toLowerCase();
+          if (mode2 !== "href") {
+            this.ctx.errors.push({ line: modeTok2?.startLine ?? 1, column: modeTok2?.startColumn ?? 1, severity: "error", code: "FL-CLICK-MODE-INVALID", message: `Unknown click mode '${modeTok2?.image}'. Use 'href' or 'call'.`, hint: 'Examples: href "\u2026" | call fn()' });
+            return;
+          }
+          if (!urlTok) {
+            this.ctx.errors.push({ line: modeTok2?.startLine ?? 1, column: modeTok2?.startColumn ?? 1, severity: "error", code: "FL-CLICK-HREF-URL-MISSING", message: "'click \u2026 href' requires a quoted URL.", hint: 'Example: click A href "https://example.com" "Open" _blank' });
+          }
+          if (tgtTok && !/^_(blank|self|parent|top)$/i.test(String(tgtTok.image || ""))) {
+            this.ctx.errors.push({ line: tgtTok.startLine ?? 1, column: tgtTok.startColumn ?? 1, severity: "warning", code: "FL-CLICK-TARGET-UNKNOWN", message: `Unknown target '${tgtTok.image}'. Use _blank/_self/_parent/_top.`, hint: "Example: \u2026 _blank" });
+          }
+          return;
+        }
+        if (call) {
+          const ch = call.children || {};
+          const modeTok2 = ch.mode?.[0];
+          const mode2 = String(modeTok2?.image || "").toLowerCase();
+          if (!(mode2 === "call" || mode2 === "callback")) {
+            this.ctx.errors.push({ line: modeTok2?.startLine ?? 1, column: modeTok2?.startColumn ?? 1, severity: "error", code: "FL-CLICK-MODE-INVALID", message: `Unknown click mode '${modeTok2?.image}'. Use 'href' or 'call'.`, hint: 'Examples: href "\u2026" | call fn()' });
+            return;
+          }
+          const fnTok = ch.fn?.[0];
+          if (!fnTok) {
+            this.ctx.errors.push({ line: modeTok2?.startLine ?? 1, column: modeTok2?.startColumn ?? 1, severity: "error", code: "FL-CLICK-CALL-NAME-MISSING", message: "'click \u2026 call' requires a function name.", hint: 'Example: click A call doThing() "Tooltip"' });
+          }
+          const tipTok = ch.tooltip?.[0];
+          if (tipTok) {
+            this.ctx.errors.push({ line: tipTok.startLine ?? 1, column: tipTok.startColumn ?? 1, severity: "error", code: "FL-CLICK-CALL-EXTRA-TEXT", message: "Tooltip/text after 'call()' is not supported by Mermaid CLI.", hint: "Use: click A call doThing()" });
+          }
+          return;
+        }
+        const ids = ctx.Identifier || [];
+        const q3 = ctx.QuotedString || [];
+        const t0 = ids[0];
+        const modeTok = ids[1];
+        const mode = (modeTok?.image || "").toLowerCase();
+        if (!mode) {
+          this.ctx.errors.push({
+            line: t0?.startLine ?? 1,
+            column: t0?.startColumn ?? 1,
+            severity: "error",
+            code: "FL-CLICK-MODE-MISSING",
+            message: "After 'click <id>' specify 'href' or 'call'.",
+            hint: 'Examples: click A href "https://\u2026" "Tip" _blank | click A call doThing() "Tip"'
+          });
+          return;
+        }
+        if (mode === "href") {
+          if (q3.length < 1) {
+            this.ctx.errors.push({
+              line: modeTok.startLine ?? 1,
+              column: modeTok.startColumn ?? 1,
+              severity: "error",
+              code: "FL-CLICK-HREF-URL-MISSING",
+              message: "'click \u2026 href' requires a quoted URL.",
+              hint: 'Example: click A href "https://example.com" "Open" _blank'
+            });
+          }
+          const tgt = ids[2];
+          if (tgt && !/^_(blank|self|parent|top)$/i.test(tgt.image || "")) {
+            this.ctx.errors.push({
+              line: tgt.startLine ?? 1,
+              column: tgt.startColumn ?? 1,
+              severity: "warning",
+              code: "FL-CLICK-TARGET-UNKNOWN",
+              message: `Unknown target '${tgt.image}'. Use _blank/_self/_parent/_top.`,
+              hint: "Example: \u2026 _blank"
+            });
+          }
+          return;
+        }
+        if (mode === "call" || mode === "callback") {
+          const fnTok = ids[2];
+          if (!fnTok) {
+            this.ctx.errors.push({
+              line: modeTok.startLine ?? 1,
+              column: modeTok.startColumn ?? 1,
+              severity: "error",
+              code: "FL-CLICK-CALL-NAME-MISSING",
+              message: "'click \u2026 call' requires a function name.",
+              hint: 'Example: click A call doThing() "Tooltip"'
+            });
+          }
+          return;
+        }
+        this.ctx.errors.push({
+          line: modeTok.startLine ?? 1,
+          column: modeTok.startColumn ?? 1,
+          severity: "error",
+          code: "FL-CLICK-MODE-INVALID",
+          message: `Unknown click mode '${modeTok.image}'. Use 'href' or 'call'.`,
+          hint: 'Examples: href "\u2026" | call fn()'
+        });
+      }
+      linkStyleStatement(ctx) {
+        const idxNode = ctx.linkStyleIndexList?.[0];
+        const pairNode = ctx.linkStylePairs?.[0];
+        const getTokens = (node, name14) => node ? (node.children || {})[name14] || [] : [];
+        const idxToks = getTokens(idxNode, "index");
+        const nums = idxToks.map((t3) => parseInt(t3.image, 10)).filter((n3) => Number.isFinite(n3));
+        if (nums.length === 0) {
+          const anyTok = ctx.LinkStyleKeyword?.[0] || idxToks[0];
+          this.ctx.errors.push({ line: anyTok?.startLine ?? 1, column: anyTok?.startColumn ?? 1, severity: "error", code: "FL-LINKSTYLE-NO-INDICES", message: "'linkStyle' requires one or more link indices (comma separated).", hint: "Example: linkStyle 0,1 stroke:#f66,stroke-width:2px" });
+          return;
+        }
+        const pairChildren = pairNode?.children || {};
+        const pairCount = (pairChildren.linkStylePair || []).length;
+        if (!pairCount) {
+          const firstNum = idxToks[0];
+          this.ctx.errors.push({ line: firstNum?.startLine ?? 1, column: firstNum?.startColumn ?? 1, severity: "error", code: "FL-LINKSTYLE-MISSING-STYLE", message: "Missing style declarations after indices.", hint: "Example: linkStyle 0 stroke:#f00,stroke-width:2px" });
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const n3 of nums) {
+          if (seen.has(n3)) {
+            const numTok = idxToks.find((t3) => parseInt(t3.image, 10) === n3);
+            this.ctx.errors.push({ line: numTok?.startLine ?? 1, column: numTok?.startColumn ?? 1, severity: "warning", code: "FL-LINKSTYLE-DUPLICATE-INDEX", message: `Duplicate linkStyle index ${n3}.`, hint: "Remove duplicates." });
+          }
+          seen.add(n3);
+        }
+        for (const n3 of nums) {
+          if (!(n3 >= 0 && n3 < this.edgeCount)) {
+            const numTok = idxToks.find((t3) => parseInt(t3.image, 10) === n3);
+            this.ctx.errors.push({ line: numTok?.startLine ?? 1, column: numTok?.startColumn ?? 1, severity: "error", code: "FL-LINKSTYLE-INDEX-OUT-OF-RANGE", message: `linkStyle index ${n3} is out of range (0..${Math.max(0, this.edgeCount - 1)}).`, hint: `Use an index between 0 and ${Math.max(0, this.edgeCount - 1)} or add more links first.` });
+          }
+        }
+      }
       subgraph(ctx) {
         if (ctx.subgraphStatement)
           ctx.subgraphStatement.forEach((s3) => this.visit(s3));
@@ -43575,14 +43904,109 @@ var init_semantics = __esm({
       nodeStatement(ctx) {
         if (ctx.nodeOrParallelGroup)
           ctx.nodeOrParallelGroup.forEach((n3) => this.visit(n3));
-      }
+        const linksHere = Array.isArray(ctx.link) ? ctx.link.length : 0;
+        if (linksHere > 0)
+          this.edgeCount += linksHere;
+      }
+      // Edge attribute object statements must target a known edge id
+      // Edge attribute statements are parsed as nodeStatements with a typed attrObject and no links.
+      // If such a line targets a known edge id, treat it as edge-attr at build time; otherwise keep as a node.
+      // Here we only surface an error when it looks like an edge-attr targeting an unknown edge id (id starts with 'e' and no link).
+      // We keep this heuristic conservative to avoid false positives on typed node shapes.
+      // (Validation that applies the attributes happens in the builder.)
       nodeOrParallelGroup(ctx) {
         if (ctx.node)
           ctx.node.forEach((n3) => this.visit(n3));
       }
       node(ctx) {
+        const hasAttr = Array.isArray(ctx.attrObject) && ctx.attrObject.length > 0;
+        const hasShape = Array.isArray(ctx.nodeShape) && ctx.nodeShape.length > 0;
+        if (hasAttr && hasShape) {
+          const tokArr = ctx.attrObject?.[0]?.children?.attrLCurly || [];
+          const tok = tokArr[0];
+          this.ctx.errors.push({
+            line: tok?.startLine ?? 1,
+            column: tok?.startColumn ?? 1,
+            severity: "warning",
+            code: "FL-TYPED-SHAPE-CONFLICT",
+            message: "Both bracket shape and '@{ shape: \u2026 }' provided. Bracket shape will be used.",
+            hint: 'Pick one style: either A[Label] or A@{ shape: rect, label: "Label" }'
+          });
+        }
         if (ctx.nodeShape)
           ctx.nodeShape.forEach((n3) => this.visit(n3));
+        if (hasAttr) {
+          const attr = ctx.attrObject?.[0];
+          const pairs = attr?.children?.attrPair || [];
+          const validKeys = /* @__PURE__ */ new Set(["shape", "label", "padding", "cornerRadius", "icon", "image"]);
+          const shapes = /* @__PURE__ */ new Set(["rect", "round", "rounded", "stadium", "subroutine", "circle", "cylinder", "diamond", "trapezoid", "trapezoidAlt", "parallelogram", "hexagon", "lean-l", "lean-r", "icon", "image"]);
+          for (const p3 of pairs) {
+            const keyTok = p3.children?.attrKey?.[0];
+            const valTok = p3.children?.QuotedString?.[0] || p3.children?.Identifier?.[0] || p3.children?.NumberLiteral?.[0] || p3.children?.Text?.[0];
+            if (!keyTok)
+              continue;
+            const key = keyTok.image;
+            if (!validKeys.has(key)) {
+              this.ctx.errors.push({
+                line: keyTok.startLine ?? 1,
+                column: keyTok.startColumn ?? 1,
+                severity: "warning",
+                code: "FL-TYPED-KEY-UNKNOWN",
+                message: `Unknown typed-shape key '${key}'.`,
+                hint: "Allowed keys: shape, label, padding, cornerRadius, icon, image"
+              });
+              continue;
+            }
+            if (key === "shape" && valTok) {
+              const v3 = String(valTok.image).replace(/^"|"$/g, "");
+              if (!shapes.has(v3)) {
+                this.ctx.errors.push({
+                  line: valTok.startLine ?? 1,
+                  column: valTok.startColumn ?? 1,
+                  severity: "error",
+                  code: "FL-TYPED-SHAPE-UNKNOWN",
+                  message: `Unknown shape '${v3}' in '@{ shape: \u2026 }'.`,
+                  hint: "Use one of: rect, round, stadium, subroutine, circle, cylinder, diamond, trapezoid, parallelogram, hexagon, lean-l, lean-r, icon, image"
+                });
+              } else {
+                const supportedByCli = /* @__PURE__ */ new Set(["rect", "round", "rounded", "diamond", "circle", "cylinder", "stadium", "subroutine", "lean-l", "lean-r"]);
+                if (!supportedByCli.has(v3)) {
+                  this.ctx.errors.push({
+                    line: valTok.startLine ?? 1,
+                    column: valTok.startColumn ?? 1,
+                    severity: "error",
+                    code: "FL-TYPED-SHAPE-UNSUPPORTED",
+                    message: `Typed shape '${v3}' is not supported by current Mermaid CLI.`,
+                    hint: 'Use one of: rect, rounded, diamond, circle, cylinder, stadium, subroutine, "lean-l", "lean-r"'
+                  });
+                }
+              }
+            }
+            if (key === "label" && valTok && valTok.tokenType?.name !== "QuotedString") {
+              this.ctx.errors.push({
+                line: valTok.startLine ?? 1,
+                column: valTok.startColumn ?? 1,
+                severity: "warning",
+                code: "FL-TYPED-LABEL-NOT-STRING",
+                message: "Typed-shape 'label' should be a quoted string.",
+                hint: 'Example: A@{ shape: rect, label: "Start" }'
+              });
+            }
+            if ((key === "padding" || key === "cornerRadius") && valTok) {
+              const raw = String(valTok.image).replace(/^"|"$/g, "");
+              if (!/^\d+(px)?$/.test(raw)) {
+                this.ctx.errors.push({
+                  line: valTok.startLine ?? 1,
+                  column: valTok.startColumn ?? 1,
+                  severity: "warning",
+                  code: "FL-TYPED-NUMERIC-EXPECTED",
+                  message: `'${key}' expects a number (optionally with px).`,
+                  hint: `Use: ${key}: 8 or ${key}: "8px"`
+                });
+              }
+            }
+          }
+        }
       }
       checkEmptyContent(openTok, contentNodes) {
         if (!contentNodes || contentNodes.length === 0) {
@@ -43718,6 +44142,7 @@ var init_semantics = __esm({
         if (openTok) {
           this.checkEmptyContent(openTok, contentNodes.length ? contentNodes : void 0);
           this.checkDoubleInSingleQuoted(contentNodes);
+          this.checkBackticksInContent(contentNodes);
           this.warnParensInUnquoted(contentNodes);
           if (this.ctx.strict) {
             let quoted = false;
@@ -43746,6 +44171,93 @@ var init_semantics = __esm({
           }
         }
       }
+      checkBackticksInContent(contentNodes) {
+        if (!contentNodes)
+          return;
+        for (const cn of contentNodes) {
+          const ch = cn.children || {};
+          const inspectTok = (tk) => {
+            if (!tk)
+              return false;
+            const img = String(tk.image || "");
+            const idx = img.indexOf("`");
+            if (idx >= 0) {
+              const col = (tk.startColumn ?? 1) + idx;
+              this.ctx.errors.push({
+                line: tk.startLine ?? 1,
+                column: col,
+                severity: "warning",
+                code: "FL-LABEL-BACKTICK",
+                message: "Backticks (`\u2026`) inside node labels are not supported by Mermaid.",
+                hint: 'Remove the backticks or use quotes instead, e.g., "GITHUB_ACTIONS" and "--cli".',
+                length: 1
+              });
+              return true;
+            }
+            return false;
+          };
+          const texts = ch.Text || [];
+          for (const tk of texts) {
+            if (inspectTok(tk))
+              return;
+          }
+          const qs = ch.QuotedString || [];
+          for (const tk of qs) {
+            if (inspectTok(tk))
+              return;
+          }
+        }
+      }
+    };
+    NodeIdCollector = class extends BaseVisitor {
+      constructor() {
+        super();
+        this.ids = /* @__PURE__ */ new Set();
+        this.edgeIds = /* @__PURE__ */ new Set();
+        this.validateVisitor();
+      }
+      node(ctx) {
+        const idTok = ctx.nodeId && ctx.nodeId[0];
+        const idNumTok = ctx.nodeIdNum && ctx.nodeIdNum[0];
+        if (idTok)
+          this.ids.add(String(idTok.image));
+        else if (idNumTok)
+          this.ids.add(String(idNumTok.image));
+      }
+      link(ctx) {
+        const t3 = ctx.edgeId?.[0];
+        if (t3)
+          this.edgeIds.add(String(t3.image));
+      }
+      nodeOrParallelGroup(ctx) {
+        if (ctx.node)
+          ctx.node.forEach((n3) => this.visit(n3));
+      }
+      nodeStatement(ctx) {
+        if (ctx.nodeOrParallelGroup)
+          ctx.nodeOrParallelGroup.forEach((n3) => this.visit(n3));
+        if (ctx.link)
+          ctx.link.forEach((ln) => this.visit(ln));
+      }
+      edgeAttrStatement(ctx) {
+        const t3 = ctx.edgeId?.[0];
+        if (t3)
+          this.edgeIds.add(String(t3.image));
+      }
+      statement(ctx) {
+        for (const k3 of Object.keys(ctx)) {
+          const arr = ctx[k3];
+          if (Array.isArray(arr))
+            arr.forEach((n3) => {
+              if (n3 && typeof n3.name === "string")
+                this.visit(n3);
+            });
+        }
+      }
+      diagram(ctx) {
+        if (ctx.statement)
+          ctx.statement.forEach((s3) => this.visit(s3));
+      }
     };
   }
 });
@@ -43783,11 +44295,29 @@ function detectDoubleInDouble(tokens, opts) {
     byLine.get(ln).push(tk);
   }
   const ends = new Set(opts.scopeEndTokenNames || []);
+  const starts = new Set(opts.scopeStartTokenNames || []);
   for (const [ln, arr] of byLine) {
     for (let i3 = 0; i3 < arr.length; i3++) {
       const t3 = arr[i3];
       if (t3.tokenType?.name !== "QuotedString")
         continue;
+      if (starts.size > 0) {
+        let startIdx = -1;
+        for (let k3 = i3 - 1; k3 >= 0; k3--) {
+          const s3 = arr[k3];
+          if (starts.has(s3.tokenType?.name || "")) {
+            startIdx = k3;
+            break;
+          }
+        }
+        if (startIdx === -1)
+          continue;
+        const sTok = arr[startIdx];
+        const prevTok = arr[startIdx - 1];
+        if (sTok.tokenType?.name === "DiamondOpen" && prevTok?.tokenType?.name === "AtSign") {
+          continue;
+        }
+      }
       for (let j3 = i3 + 1; j3 < arr.length; j3++) {
         const u3 = arr[j3];
         if (ends.size > 0 && ends.has(u3.tokenType?.name || ""))
@@ -43955,8 +44485,9 @@ function mapFlowchartParserError(err, text) {
       length: len
     };
   }
-  if (isInRule(err, "nodeStatement") && err.name === "NoViableAltException") {
-    if ((err.message || "").includes("[Newline") && (err.message || "").includes("[EOF")) {
+  if (err.name === "NoViableAltException" || err.name === "MismatchedTokenException") {
+    const msg = err.message || "";
+    if (tokType === "Identifier" && msg.includes("Newline") && msg.includes("EOF")) {
       return {
         line,
         column,
@@ -44564,11 +45095,11 @@ function mapStateParserError(err, text) {
     return { line, column, severity: "error", code: "ST-NOTE-MALFORMED", message: "Malformed note: missing colon before note text.", hint: "Example: Note right of A: message", length: len };
   }
   if (isInRule(err, "stateBlock") && err.name === "MismatchedTokenException" && expecting(err, "RCurly")) {
-    if (/---/.test(ltxt)) {
-      return { line, column, severity: "error", code: "ST-CONCURRENCY-UNSUPPORTED", message: "Concurrency separator '---' is not supported in Mermaid state diagrams.", hint: "Use separate states or regions without '---'.", length: len };
-    }
     return { line, column, severity: "error", code: "ST-BLOCK-MISSING-RBRACE", message: "Missing '}' to close a state block.", hint: "Close the block: state Foo { ... }", length: len };
   }
+  if ((err.name === "NoViableAltException" || err.name === "MismatchedTokenException") && tokType === "Dashes" && !isInRule(err, "innerStatement")) {
+    return { line, column, severity: "error", code: "ST-CONCURRENCY-OUTSIDE-BLOCK", message: "'---' is only allowed inside 'state { \u2026 }' blocks.", hint: "Move '---' inside a composite state block: state A { \u2026 --- \u2026 }", length: len };
+  }
   const dblEsc = (ltxt.match(/\\\"/g) || []).length;
   const dq = (ltxt.match(/\"/g) || []).length - dblEsc;
   if (dq >= 3) {
@@ -44674,9 +45205,60 @@ function validateFlowchart(text, options = {}) {
           "StadiumClose",
           "CylinderClose",
           "HexagonClose"
+        ],
+        scopeStartTokenNames: [
+          "SquareOpen",
+          "RoundOpen",
+          "DiamondOpen",
+          "DoubleSquareOpen",
+          "DoubleRoundOpen",
+          "StadiumOpen",
+          "CylinderOpen",
+          "HexagonOpen"
         ]
       }).filter((e3) => !seenDoubleLines.has(e3.line) && !escapedLinesAll.has(e3.line));
       const errs = escWarn.concat(dbl);
+      const generic = (prevErrors || []).filter((e3) => e3.severity === "error" && !("code" in e3) && typeof e3.message === "string");
+      for (const ge of generic) {
+        const msg = String(ge.message || "");
+        if (msg.includes("Newline") && msg.includes("EOF")) {
+          errs.push({
+            line: ge.line ?? 1,
+            column: ge.column ?? 1,
+            severity: "error",
+            code: "FL-LINK-MISSING",
+            message: "Two nodes on one line must be connected with an arrow.",
+            hint: "Insert --> between nodes, e.g., A --> B."
+          });
+        }
+      }
+      {
+        const lines = text2.split(/\r?\n/);
+        const nodeRef = String.raw`[A-Za-z0-9_]+(?:\[[^\]]*\]|\([^\)]*\)|\{[^}]*\}|\[\[[^\]]*\]\]|\(\([^\)]*\)\))?`;
+        const re = new RegExp(String.raw`^\s*(${nodeRef})\s+(${nodeRef})\s*;?\s*$`);
+        const skipStart = /^(?:\s*)(style|classDef|class|click|linkStyle|subgraph|end|graph|flowchart|direction)\b/;
+        for (let i3 = 0; i3 < lines.length; i3++) {
+          const raw = lines[i3] || "";
+          const ln = i3 + 1;
+          if (!raw.trim())
+            continue;
+          if (skipStart.test(raw))
+            continue;
+          const m3 = re.exec(raw);
+          if (m3) {
+            const idxSecond = raw.indexOf(m3[2]);
+            const col = idxSecond >= 0 ? idxSecond + 1 : 1;
+            errs.push({
+              line: ln,
+              column: col,
+              severity: "error",
+              code: "FL-LINK-MISSING",
+              message: "Two nodes on one line must be connected with an arrow.",
+              hint: "Insert --> between nodes, e.g., A --> B."
+            });
+          }
+        }
+      }
       const dblEsc = (text2.match(/\\\"/g) || []).length;
       const dq = (text2.match(/\"/g) || []).length - dblEsc;
       const sq = (text2.match(/'/g) || []).length;
@@ -44882,7 +45464,7 @@ var init_validate2 = __esm({
 function tokenize3(text) {
   return SequenceLexer.tokenize(text);
 }
-var Identifier2, NumberLiteral3, SequenceKeyword, ParticipantKeyword, ActorKeyword, AsKeyword, AutonumberKeyword, OffKeyword, NoteKeyword, LeftKeyword, RightKeyword, OverKeyword, OfKeyword, ActivateKeyword, DeactivateKeyword, CreateKeyword, DestroyKeyword, AltKeyword, ElseKeyword, OptionKeyword, OptKeyword, LoopKeyword, ParKeyword, AndKeyword, RectKeyword, CriticalKeyword, BoxKeyword, EndKeyword2, LinksKeyword, LinkKeyword, BreakKeyword, BidirAsyncDotted, BidirAsync, DottedAsync, Async, Dotted, Solid, DottedCross, Cross, DottedOpen, Open, Plus, Minus, Comma2, Colon3, LParen, RParen, QuotedString3, Comment3, WhiteSpace3, Newline3, Text3, allTokens3, SequenceLexer;
+var Identifier2, NumberLiteral3, SequenceKeyword, ParticipantKeyword, ActorKeyword, AsKeyword, AutonumberKeyword, OffKeyword, NoteKeyword, LeftKeyword, RightKeyword, OverKeyword, OfKeyword, TitleKeyword2, AccTitleKeyword, AccDescrKeyword, ActivateKeyword, DeactivateKeyword, CreateKeyword, DestroyKeyword, AltKeyword, ElseKeyword, OptionKeyword, OptKeyword, LoopKeyword, ParKeyword, AndKeyword, RectKeyword, CriticalKeyword, BoxKeyword, EndKeyword2, LinksKeyword, LinkKeyword, PropertiesKeyword, DetailsKeyword, BreakKeyword, BidirAsyncDotted, BidirAsync, DottedAsync, Async, Dotted, Solid, DottedCross, Cross, DottedOpen, Open, Plus, Minus, Comma2, Colon3, LParen, RParen, QuotedString3, Comment3, WhiteSpace3, Newline3, Text3, allTokens3, SequenceLexer;
 var init_lexer4 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/sequence/lexer.js"() {
     init_api5();
@@ -44899,6 +45481,9 @@ var init_lexer4 = __esm({
     RightKeyword = createToken({ name: "RightKeyword", pattern: /right/i, longer_alt: Identifier2 });
     OverKeyword = createToken({ name: "OverKeyword", pattern: /over/i, longer_alt: Identifier2 });
     OfKeyword = createToken({ name: "OfKeyword", pattern: /of/i, longer_alt: Identifier2 });
+    TitleKeyword2 = createToken({ name: "TitleKeyword", pattern: /title/i, longer_alt: Identifier2 });
+    AccTitleKeyword = createToken({ name: "AccTitleKeyword", pattern: /acc_title|accTitle/i, longer_alt: Identifier2 });
+    AccDescrKeyword = createToken({ name: "AccDescrKeyword", pattern: /acc_descr|accDescr/i, longer_alt: Identifier2 });
     ActivateKeyword = createToken({ name: "ActivateKeyword", pattern: /activate/i, longer_alt: Identifier2 });
     DeactivateKeyword = createToken({ name: "DeactivateKeyword", pattern: /deactivate/i, longer_alt: Identifier2 });
     CreateKeyword = createToken({ name: "CreateKeyword", pattern: /create/i, longer_alt: Identifier2 });
@@ -44916,6 +45501,8 @@ var init_lexer4 = __esm({
     EndKeyword2 = createToken({ name: "EndKeyword", pattern: /end/i, longer_alt: Identifier2 });
     LinksKeyword = createToken({ name: "LinksKeyword", pattern: /links/i, longer_alt: Identifier2 });
     LinkKeyword = createToken({ name: "LinkKeyword", pattern: /link/i, longer_alt: Identifier2 });
+    PropertiesKeyword = createToken({ name: "PropertiesKeyword", pattern: /properties/i, longer_alt: Identifier2 });
+    DetailsKeyword = createToken({ name: "DetailsKeyword", pattern: /details/i, longer_alt: Identifier2 });
     BreakKeyword = createToken({ name: "BreakKeyword", pattern: /break/i, longer_alt: Identifier2 });
     BidirAsyncDotted = createToken({ name: "BidirAsyncDotted", pattern: /<<-->>/ });
     BidirAsync = createToken({ name: "BidirAsync", pattern: /<<->>/ });
@@ -44948,6 +45535,9 @@ var init_lexer4 = __esm({
       Newline3,
       // Header/Keywords
       SequenceKeyword,
+      TitleKeyword2,
+      AccTitleKeyword,
+      AccDescrKeyword,
       ParticipantKeyword,
       ActorKeyword,
       AsKeyword,
@@ -44976,6 +45566,8 @@ var init_lexer4 = __esm({
       EndKeyword2,
       LinksKeyword,
       LinkKeyword,
+      PropertiesKeyword,
+      DetailsKeyword,
       // Arrows
       BidirAsyncDotted,
       BidirAsync,
@@ -45027,6 +45619,7 @@ var init_parser4 = __esm({
         });
         this.line = this.RULE("line", () => {
           this.OR([
+            { ALT: () => this.SUBRULE(this.metaStmt) },
             { ALT: () => this.SUBRULE(this.participantDecl) },
             { ALT: () => this.SUBRULE(this.autonumberStmt) },
             { ALT: () => this.SUBRULE(this.noteStmt) },
@@ -45035,6 +45628,8 @@ var init_parser4 = __esm({
             { ALT: () => this.SUBRULE(this.createStmt) },
             { ALT: () => this.SUBRULE(this.destroyStmt) },
             { ALT: () => this.SUBRULE(this.linkStmt) },
+            { ALT: () => this.SUBRULE(this.propertiesStmt) },
+            { ALT: () => this.SUBRULE(this.detailsStmt) },
             { ALT: () => this.SUBRULE(this.altBlock) },
             { ALT: () => this.SUBRULE(this.optBlock) },
             { ALT: () => this.SUBRULE(this.loopBlock) },
@@ -45047,6 +45642,18 @@ var init_parser4 = __esm({
             { ALT: () => this.SUBRULE(this.blankLine) }
           ]);
         });
+        this.metaStmt = this.RULE("metaStmt", () => {
+          this.OR([
+            { ALT: () => this.CONSUME(TitleKeyword2) },
+            { ALT: () => this.CONSUME(AccTitleKeyword) },
+            { ALT: () => this.CONSUME(AccDescrKeyword) }
+          ]);
+          this.OPTION(() => this.SUBRULE(this.lineRemainder));
+          this.OR2([
+            { ALT: () => this.AT_LEAST_ONE(() => this.CONSUME(Newline3)) },
+            { ALT: () => this.CONSUME(EOF) }
+          ]);
+        });
         this.blankLine = this.RULE("blankLine", () => {
           this.AT_LEAST_ONE(() => this.CONSUME(Newline3));
         });
@@ -45175,6 +45782,24 @@ var init_parser4 = __esm({
             { ALT: () => this.CONSUME(EOF) }
           ]);
         });
+        this.propertiesStmt = this.RULE("propertiesStmt", () => {
+          this.CONSUME(PropertiesKeyword);
+          this.OPTION(() => this.CONSUME(Colon3));
+          this.OPTION1(() => this.SUBRULE(this.lineRemainder));
+          this.OR2([
+            { ALT: () => this.AT_LEAST_ONE(() => this.CONSUME(Newline3)) },
+            { ALT: () => this.CONSUME(EOF) }
+          ]);
+        });
+        this.detailsStmt = this.RULE("detailsStmt", () => {
+          this.CONSUME(DetailsKeyword);
+          this.OPTION(() => this.CONSUME(Colon3));
+          this.OPTION1(() => this.SUBRULE(this.lineRemainder));
+          this.OR2([
+            { ALT: () => this.AT_LEAST_ONE(() => this.CONSUME(Newline3)) },
+            { ALT: () => this.CONSUME(EOF) }
+          ]);
+        });
         this.messageStmt = this.RULE("messageStmt", () => {
           this.SUBRULE(this.actorRef);
           this.SUBRULE(this.arrow);
@@ -45245,7 +45870,7 @@ var init_parser4 = __esm({
         });
         this.parBlock = this.RULE("parBlock", () => {
           this.CONSUME(ParKeyword);
-          this.OPTION(() => this.SUBRULE(this.lineRemainder));
+          this.OPTION(() => this.SUBRULE(this.parHeader));
           this.AT_LEAST_ONE(() => this.CONSUME(Newline3));
           this.MANY(() => this.SUBRULE(this.line));
           this.MANY2(() => {
@@ -45260,6 +45885,23 @@ var init_parser4 = __esm({
             { ALT: () => this.CONSUME3(EOF) }
           ]);
         });
+        this.parHeader = this.RULE("parHeader", () => {
+          this.OR([
+            {
+              GATE: () => this.LA(1).tokenType === OverKeyword,
+              ALT: () => {
+                this.CONSUME(OverKeyword);
+                this.SUBRULE(this.actorRef);
+                this.OPTION(() => {
+                  this.CONSUME(Comma2);
+                  this.SUBRULE2(this.actorRef);
+                });
+                this.OPTION1(() => this.SUBRULE(this.lineRemainder));
+              }
+            },
+            { ALT: () => this.SUBRULE2(this.lineRemainder) }
+          ]);
+        });
         this.criticalBlock = this.RULE("criticalBlock", () => {
           this.CONSUME(CriticalKeyword);
           this.OPTION(() => this.SUBRULE(this.lineRemainder));
@@ -45334,6 +45976,9 @@ var init_parser4 = __esm({
             { ALT: () => this.CONSUME(BreakKeyword) },
             { ALT: () => this.CONSUME(BoxKeyword) },
             { ALT: () => this.CONSUME(EndKeyword2) },
+            { ALT: () => this.CONSUME(TitleKeyword2) },
+            { ALT: () => this.CONSUME(AccTitleKeyword) },
+            { ALT: () => this.CONSUME(AccDescrKeyword) },
             { ALT: () => this.CONSUME(NoteKeyword) },
             { ALT: () => this.CONSUME(LeftKeyword) },
             { ALT: () => this.CONSUME(RightKeyword) },
@@ -45362,12 +46007,186 @@ var init_parser4 = __esm({
 function analyzeSequence(_cst, _tokens) {
   const ctx = { tokens: _tokens };
   const v3 = new SequenceSemanticsVisitor(ctx);
-  return [];
+  const errs = [];
+  const firstByLine = /* @__PURE__ */ new Map();
+  for (const tk of _tokens) {
+    const ln = tk.startLine ?? 1;
+    const col = tk.startColumn ?? 1;
+    const prev = firstByLine.get(ln);
+    if (!prev || (prev.startColumn ?? Infinity) > col)
+      firstByLine.set(ln, tk);
+  }
+  for (const tok of _tokens) {
+    if (tok.tokenType === TitleKeyword2 || tok.tokenType === AccTitleKeyword || tok.tokenType === AccDescrKeyword) {
+      const isLineStart = firstByLine.get(tok.startLine ?? 1) === tok;
+      if (isLineStart)
+        errs.push({
+          line: tok.startLine ?? 1,
+          column: tok.startColumn ?? 1,
+          severity: "error",
+          code: "SE-META-UNSUPPORTED",
+          message: "Title/accTitle/accDescr are not accepted by current Mermaid CLI for sequence diagrams.",
+          hint: "Remove this line (e.g., 'title \u2026') to match mermaid-cli.",
+          length: tok.image?.length ?? 5
+        });
+    }
+    if (tok.tokenType === PropertiesKeyword && firstByLine.get(tok.startLine ?? 1) === tok) {
+      errs.push({
+        line: tok.startLine ?? 1,
+        column: tok.startColumn ?? 1,
+        severity: "error",
+        code: "SE-PROPERTIES-UNSUPPORTED",
+        message: "'properties' is not accepted by current Mermaid CLI for sequence diagrams.",
+        hint: "Remove the 'properties:' line to match mermaid-cli.",
+        length: tok.image?.length ?? 10
+      });
+    }
+    if (tok.tokenType === DetailsKeyword && firstByLine.get(tok.startLine ?? 1) === tok) {
+      errs.push({
+        line: tok.startLine ?? 1,
+        column: tok.startColumn ?? 1,
+        severity: "error",
+        code: "SE-DETAILS-UNSUPPORTED",
+        message: "'details' is not accepted by current Mermaid CLI for sequence diagrams.",
+        hint: "Remove the 'details:' line to match mermaid-cli.",
+        length: tok.image?.length ?? 7
+      });
+    }
+  }
+  const lines = /* @__PURE__ */ new Map();
+  for (const tk of _tokens) {
+    if (tk.tokenType === Newline3)
+      continue;
+    const ln = tk.startLine ?? 1;
+    (lines.get(ln) || lines.set(ln, []).get(ln)).push(tk);
+  }
+  const events = [];
+  const tokensByLine = Array.from(lines.entries()).sort((a3, b3) => a3[0] - b3[0]);
+  const grabActorRef = (arr, startIdx) => {
+    const parts = [];
+    for (let i3 = startIdx; i3 < arr.length; i3++) {
+      const tk = arr[i3];
+      if (tk.tokenType === Colon3 || tk.tokenType === Newline3)
+        break;
+      if (tk.tokenType === Identifier2 || tk.tokenType === QuotedString3 || tk.tokenType === NumberLiteral3 || tk.tokenType === Text3)
+        parts.push(tk.image);
+      if (tk.tokenType === Async || tk.tokenType === Solid || tk.tokenType === Dotted || tk.tokenType === DottedAsync || tk.tokenType === BidirAsync || tk.tokenType === BidirAsyncDotted)
+        break;
+    }
+    const raw = parts.join(" ").trim();
+    return raw.replace(/^"|"$/g, "");
+  };
+  for (const [ln, arr] of tokensByLine) {
+    if (arr.some((tk) => tk.tokenType === ActivateKeyword)) {
+      const idx = arr.findIndex((tk) => tk.tokenType === ActivateKeyword);
+      const actor = grabActorRef(arr, idx + 1);
+      if (actor)
+        events.push({ kind: "activate", line: ln, actor });
+      continue;
+    }
+    if (arr.some((tk) => tk.tokenType === DeactivateKeyword)) {
+      const idx = arr.findIndex((tk) => tk.tokenType === DeactivateKeyword);
+      const actor = grabActorRef(arr, idx + 1);
+      if (actor)
+        events.push({ kind: "deactivate", line: ln, actor });
+      continue;
+    }
+    if (arr.some((tk) => tk.tokenType === CreateKeyword)) {
+      const idx = arr.findIndex((tk) => tk.tokenType === CreateKeyword);
+      const after = arr.slice(idx + 1);
+      const aidx = after.findIndex((tk) => tk.tokenType === ParticipantKeyword || tk.tokenType === ActorKeyword);
+      const actor = aidx >= 0 ? grabActorRef(after, aidx + 1) : grabActorRef(arr, idx + 1);
+      if (actor)
+        events.push({ kind: "create", line: ln, actor });
+      continue;
+    }
+    const arrowIdx = arr.findIndex((tk) => [Async, DottedAsync, Solid, Dotted, Cross, DottedCross, DottedOpen, Open, BidirAsync, BidirAsyncDotted].includes(tk.tokenType));
+    if (arrowIdx > 0) {
+      const from = grabActorRef(arr, 0);
+      const to = grabActorRef(arr, arrowIdx + 1);
+      if (from || to) {
+        const plusTok = arr.find((tk) => tk.tokenType === Plus);
+        const minusTok = arr.find((tk) => tk.tokenType === Minus);
+        events.push({ kind: "message", line: ln, from, to, plus: Boolean(plusTok), minus: Boolean(minusTok), plusTok, minusTok });
+      }
+    }
+  }
+  const actStack = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (ev.kind === "activate" && ev.actor) {
+      const a3 = actStack.get(ev.actor) || [];
+      a3.push({ line: ev.line });
+      actStack.set(ev.actor, a3);
+    } else if (ev.kind === "deactivate" && ev.actor) {
+      const a3 = actStack.get(ev.actor) || [];
+      a3.pop();
+      actStack.set(ev.actor, a3);
+    } else if (ev.kind === "message" && ev.to) {
+      const target = ev.to;
+      const plus = Boolean(ev.plus);
+      const minus = Boolean(ev.minus);
+      const plusTok = ev.plusTok;
+      const minusTok = ev.minusTok;
+      if (plus) {
+        const a3 = actStack.get(target) || [];
+        if (a3.length > 0) {
+          const col = plusTok?.startColumn ?? 1;
+          errs.push({ line: ev.line, column: col, severity: "warning", code: "SE-ACTIVATION-ALREADY-ACTIVE", message: `Message indicates '+ (activate)' but '${target}' is already active.`, hint: `Remove '+' or deactivate first: deactivate ${target}`, length: 1 });
+        } else {
+          a3.push({ line: ev.line });
+          actStack.set(target, a3);
+        }
+      }
+      if (minus) {
+        const a3 = actStack.get(target) || [];
+        if (a3.length === 0) {
+          const col = minusTok?.startColumn ?? 1;
+          errs.push({ line: ev.line, column: col, severity: "warning", code: "SE-DEACTIVATE-NO-ACTIVE", message: `Message indicates '- (deactivate)' but '${target}' is not active.`, hint: `Remove '-' or ensure 'activate ${target}' occurred before.`, length: 1 });
+        } else {
+          a3.pop();
+          actStack.set(target, a3);
+        }
+      }
+    }
+  }
+  for (const [actor, arr] of actStack.entries()) {
+    if (arr.length) {
+      const top = arr[arr.length - 1];
+      errs.push({
+        line: top.line,
+        column: 1,
+        severity: "warning",
+        code: "SE-ACTIVATION-UNBALANCED",
+        message: `Unbalanced activation: '${actor}' was activated but not deactivated.`,
+        hint: `Add 'deactivate ${actor}' after the active section.`,
+        length: actor.length
+      });
+    }
+  }
+  for (let i3 = 0; i3 < events.length; i3++) {
+    const ev = events[i3];
+    if (ev.kind === "create" && ev.actor) {
+      const next = events[i3 + 1];
+      if (!(next && next.kind === "message" && (next.from === ev.actor || next.to === ev.actor))) {
+        errs.push({
+          line: ev.line,
+          column: 1,
+          severity: "warning",
+          code: "SE-CREATE-NO-CREATING-MESSAGE",
+          message: `Actor '${ev.actor}' is created but the next line is not a message involving it.`,
+          hint: `Add a creating message to or from '${ev.actor}' immediately after the create line.`,
+          length: ev.actor.length
+        });
+      }
+    }
+  }
+  return errs;
 }
 var BaseVisitor3, SequenceSemanticsVisitor;
 var init_semantics3 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/sequence/semantics.js"() {
     init_parser4();
+    init_lexer4();
     BaseVisitor3 = parserInstance3.getBaseCstVisitorConstructorWithDefaults();
     SequenceSemanticsVisitor = class extends BaseVisitor3 {
       constructor(ctx) {
@@ -45477,7 +46296,7 @@ var init_validate3 = __esm({
 function tokenize4(text) {
   return ClassLexer.tokenize(text);
 }
-var Identifier3, NumberLiteral4, ClassDiagramKeyword, DirectionKw, Direction2, ClassKw, AsKw, NoteKw, RelCompToAgg, RelAggToComp, RelCompBoth, RelAggBoth, LollipopLeft, LollipopRight, RelExtends, RelComposition, RelAggregation, RelDependency, RelRealization, RelAssociation, InvalidRelArrow, LCurly, RCurly, LParen2, RParen2, Colon4, Comma3, Visibility, LTlt, GTgt, QuotedString4, BacktickName, SquareOpen2, SquareClose2, Comment4, WhiteSpace4, Newline4, allTokens4, ClassLexer;
+var Identifier3, NumberLiteral4, ClassDiagramKeyword, DirectionKw, Direction2, ClassKw, AsKw, NoteKw, ForKw, RelCompToAgg, RelAggToComp, RelCompBoth, RelAggBoth, LollipopLeft, LollipopRight, RelExtends, RelComposition, RelAggregation, RelDependency, RelRealization, RelAssociation, RelDependencyLeft, RelRealizationLeft, RelExtendsRight, InvalidRelArrow, LCurly, RCurly, LParen2, RParen2, Colon4, Comma3, Visibility, LTlt, GTgt, GenericAngle, QuotedString4, BacktickName, SquareOpen2, SquareClose2, Comment4, WhiteSpace4, Newline4, allTokens4, ClassLexer;
 var init_lexer5 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/class/lexer.js"() {
     init_api5();
@@ -45489,6 +46308,7 @@ var init_lexer5 = __esm({
     ClassKw = createToken({ name: "ClassKw", pattern: /class/, longer_alt: Identifier3 });
     AsKw = createToken({ name: "AsKw", pattern: /as/, longer_alt: Identifier3 });
     NoteKw = createToken({ name: "NoteKw", pattern: /note/, longer_alt: Identifier3 });
+    ForKw = createToken({ name: "ForKw", pattern: /for/, longer_alt: Identifier3 });
     RelCompToAgg = createToken({ name: "RelCompToAgg", pattern: /\*--o/ });
     RelAggToComp = createToken({ name: "RelAggToComp", pattern: /o--\*/ });
     RelCompBoth = createToken({ name: "RelCompBoth", pattern: /\*--\*/ });
@@ -45501,6 +46321,9 @@ var init_lexer5 = __esm({
     RelDependency = createToken({ name: "RelDependency", pattern: /\.\.>/ });
     RelRealization = createToken({ name: "RelRealization", pattern: /\.\.\|>/ });
     RelAssociation = createToken({ name: "RelAssociation", pattern: /--/ });
+    RelDependencyLeft = createToken({ name: "RelDependencyLeft", pattern: /<\.\./ });
+    RelRealizationLeft = createToken({ name: "RelRealizationLeft", pattern: /<\|\.\./ });
+    RelExtendsRight = createToken({ name: "RelExtendsRight", pattern: /--\|>/ });
     InvalidRelArrow = createToken({ name: "InvalidRelArrow", pattern: /->(?!>)/ });
     LCurly = createToken({ name: "LCurly", pattern: /\{/ });
     RCurly = createToken({ name: "RCurly", pattern: /\}/ });
@@ -45511,6 +46334,7 @@ var init_lexer5 = __esm({
     Visibility = createToken({ name: "Visibility", pattern: /[+\-#~]/ });
     LTlt = createToken({ name: "LTlt", pattern: /<</ });
     GTgt = createToken({ name: "GTgt", pattern: />>/ });
+    GenericAngle = createToken({ name: "GenericAngle", pattern: /<[^\n\r>]+>/ });
     QuotedString4 = createToken({ name: "QuotedString", pattern: /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/ });
     BacktickName = createToken({ name: "BacktickName", pattern: /`(?:\\.|[^`\\])*`/ });
     SquareOpen2 = createToken({ name: "SquareOpen", pattern: /\[/ });
@@ -45527,6 +46351,7 @@ var init_lexer5 = __esm({
       ClassKw,
       AsKw,
       NoteKw,
+      ForKw,
       Direction2,
       // Relationship ops
       RelCompToAgg,
@@ -45538,6 +46363,9 @@ var init_lexer5 = __esm({
       RelRealization,
       RelDependency,
       RelExtends,
+      RelDependencyLeft,
+      RelRealizationLeft,
+      RelExtendsRight,
       RelComposition,
       RelAggregation,
       RelAssociation,
@@ -45545,6 +46373,7 @@ var init_lexer5 = __esm({
       // Punct
       LTlt,
       GTgt,
+      GenericAngle,
       LCurly,
       RCurly,
       LParen2,
@@ -45590,6 +46419,7 @@ var init_parser5 = __esm({
             { ALT: () => this.SUBRULE(this.directionStmt) },
             { ALT: () => this.SUBRULE(this.classLine) },
             { ALT: () => this.SUBRULE(this.relationStmt) },
+            { ALT: () => this.SUBRULE(this.noteStmt) },
             { ALT: () => this.SUBRULE(this.memberAssignStmt) },
             { ALT: () => this.CONSUME(Newline4) }
           ]);
@@ -45703,6 +46533,18 @@ var init_parser5 = __esm({
             { ALT: () => this.CONSUME(QuotedString4) }
           ]);
         });
+        this.noteStmt = this.RULE("noteStmt", () => {
+          this.CONSUME(NoteKw);
+          this.OPTION(() => this.CONSUME(ForKw));
+          this.SUBRULE(this.classRef);
+          this.OPTION1(() => this.CONSUME(Colon4));
+          this.OR([
+            { ALT: () => this.CONSUME(QuotedString4) },
+            { ALT: () => this.CONSUME(Identifier3) },
+            { ALT: () => this.CONSUME(NumberLiteral4) }
+          ]);
+          this.OPTION2(() => this.CONSUME(Newline4));
+        });
         this.relationOp = this.RULE("relationOp", () => {
           this.OR([
             { ALT: () => this.CONSUME(RelCompToAgg) },
@@ -45712,16 +46554,22 @@ var init_parser5 = __esm({
             { ALT: () => this.CONSUME(LollipopLeft) },
             { ALT: () => this.CONSUME(LollipopRight) },
             { ALT: () => this.CONSUME(RelExtends) },
+            { ALT: () => this.CONSUME(RelExtendsRight) },
             { ALT: () => this.CONSUME(RelComposition) },
             { ALT: () => this.CONSUME(RelAggregation) },
             { ALT: () => this.CONSUME(RelRealization) },
             { ALT: () => this.CONSUME(RelDependency) },
+            { ALT: () => this.CONSUME(RelRealizationLeft) },
+            { ALT: () => this.CONSUME(RelDependencyLeft) },
             { ALT: () => this.CONSUME(RelAssociation) }
           ]);
         });
         this.classRef = this.RULE("classRef", () => {
           this.OR([
-            { ALT: () => this.CONSUME(Identifier3) },
+            { ALT: () => {
+              this.CONSUME(Identifier3);
+              this.OPTION(() => this.CONSUME(GenericAngle));
+            } },
             { ALT: () => this.CONSUME(QuotedString4) },
             { ALT: () => this.CONSUME(BacktickName) }
           ]);
@@ -45730,14 +46578,15 @@ var init_parser5 = __esm({
           this.OR([
             { ALT: () => this.CONSUME(QuotedString4) },
             { ALT: () => this.CONSUME(Identifier3) },
-            { ALT: () => this.CONSUME(NumberLiteral4) }
+            { ALT: () => this.CONSUME(NumberLiteral4) },
+            { ALT: () => this.CONSUME(GenericAngle) }
           ]);
         });
         this.relationStmt = this.RULE("relationStmt", () => {
           this.SUBRULE(this.classRef);
-          this.OPTION1(() => this.CONSUME(QuotedString4));
+          this.OPTION1(() => this.CONSUME(QuotedString4, { LABEL: "leftCard" }));
           this.SUBRULE(this.relationOp);
-          this.OPTION2(() => this.CONSUME2(QuotedString4));
+          this.OPTION2(() => this.CONSUME2(QuotedString4, { LABEL: "rightCard" }));
           this.SUBRULE2(this.classRef);
           this.OPTION3(() => {
             this.CONSUME(Colon4);
@@ -45874,7 +46723,7 @@ var init_validate4 = __esm({
 function tokenize5(text) {
   return StateLexer.tokenize(text);
 }
-var Identifier4, NumberLiteral5, StateDiagramV2, StateDiagram, StateKw, AsKw2, DirectionKw2, Direction3, NoteKw2, LeftKw, RightKw, OfKw, OverKw, AngleAngleOpen, AngleAngleClose, Dashes, StyleClassDefKw, StyleClassKw, Start, Arrow, InvalidArrow2, Hyphen, LCurly2, RCurly2, Colon5, Comma4, QuotedString5, Comment5, WhiteSpace5, Newline5, LabelChunk, allTokens5, StateLexer;
+var Identifier4, NumberLiteral5, StateDiagramV2, StateDiagram, StateKw, AsKw2, DirectionKw2, Direction3, NoteKw2, LeftKw, RightKw, OfKw, OverKw, AngleAngleOpen, AngleAngleClose, Dashes, StyleClassDefKw, StyleClassKw, Start, HistoryShallow, HistoryDeep, Arrow, InvalidArrow2, Hyphen, LCurly2, RCurly2, Colon5, Comma4, QuotedString5, Comment5, WhiteSpace5, Newline5, LabelChunk, allTokens5, StateLexer;
 var init_lexer6 = __esm({
   "node_modules/@probelabs/maid/out/diagrams/state/lexer.js"() {
     init_api5();
@@ -45897,6 +46746,8 @@ var init_lexer6 = __esm({
     StyleClassDefKw = createToken({ name: "StyleClassDefKw", pattern: /classDef/, longer_alt: Identifier4 });
     StyleClassKw = createToken({ name: "StyleClassKw", pattern: /class(?!Diagram)/, longer_alt: Identifier4 });
     Start = createToken({ name: "Start", pattern: /\[\*\]/ });
+    HistoryShallow = createToken({ name: "HistoryShallow", pattern: /\[H\]/ });
+    HistoryDeep = createToken({ name: "HistoryDeep", pattern: /\[H\*\]/ });
     Arrow = createToken({ name: "Arrow", pattern: /-->/ });
     InvalidArrow2 = createToken({ name: "InvalidArrow", pattern: /->(?!>)/ });
     Hyphen = createToken({ name: "Hyphen", pattern: /-/ });
@@ -45926,6 +46777,8 @@ var init_lexer6 = __esm({
       AngleAngleOpen,
       AngleAngleClose,
       Start,
+      HistoryDeep,
+      HistoryShallow,
       Arrow,
       InvalidArrow2,
       Dashes,
@@ -45974,8 +46827,7 @@ var init_parser6 = __esm({
             { ALT: () => this.SUBRULE(this.transitionStmt) },
             { ALT: () => this.SUBRULE(this.stateBlock) },
             { ALT: () => this.SUBRULE(this.stateDecl) },
-            // Concurrency separator (---) is not supported by mermaid-cli v11; treat as invalid (handled in postLex)
-            // { ALT: () => this.CONSUME(t.Dashes) },
+            // '---' only allowed inside state blocks; not at top level
             { ALT: () => this.SUBRULE(this.stateDescriptionStmt) },
             { ALT: () => this.SUBRULE(this.noteStmt) },
             { ALT: () => this.SUBRULE(this.styleStmt) },
@@ -46007,6 +46859,8 @@ var init_parser6 = __esm({
         this.actorRef = this.RULE("actorRef", () => {
           this.OR([
             { ALT: () => this.CONSUME(Start) },
+            { ALT: () => this.CONSUME(HistoryDeep) },
+            { ALT: () => this.CONSUME(HistoryShallow) },
             {
               ALT: () => {
                 this.OR2([
@@ -46079,10 +46933,23 @@ var init_parser6 = __esm({
             { ALT: () => this.CONSUME(QuotedString5) }
           ]);
           this.CONSUME(LCurly2);
-          this.MANY(() => this.SUBRULE(this.statement));
+          this.MANY(() => this.SUBRULE(this.innerStatement));
           this.CONSUME(RCurly2);
           this.OPTION(() => this.CONSUME(Newline5));
         });
+        this.innerStatement = this.RULE("innerStatement", () => {
+          this.OR([
+            { ALT: () => this.SUBRULE(this.directionStmt) },
+            { ALT: () => this.SUBRULE(this.transitionStmt) },
+            { ALT: () => this.SUBRULE(this.stateBlock) },
+            { ALT: () => this.SUBRULE(this.stateDecl) },
+            { ALT: () => this.CONSUME(Dashes) },
+            { ALT: () => this.SUBRULE(this.stateDescriptionStmt) },
+            { ALT: () => this.SUBRULE(this.noteStmt) },
+            { ALT: () => this.SUBRULE(this.styleStmt) },
+            { ALT: () => this.CONSUME(Newline5) }
+          ]);
+        });
         this.noteStmt = this.RULE("noteStmt", () => {
           this.CONSUME(NoteKw2);
           this.OR([
@@ -46221,6 +47088,72 @@ function validateState(text, _options = {}) {
           errors.push({ line: Math.max(1, lines.length), column: 1, severity: "error", code: "ST-BLOCK-MISSING-RBRACE", message: "Missing '}' to close a state block.", hint: "Close the block: state Foo { ... }" });
         }
       }
+      const stack = [];
+      const pushBlock = (ln) => stack.push({ start: ln, content: [], seps: [] });
+      const top = () => stack[stack.length - 1];
+      for (let i3 = 0; i3 < lines.length; i3++) {
+        const raw = lines[i3] || "";
+        const ln = i3 + 1;
+        if (/^\s*state\b.*\{\s*$/.test(raw)) {
+          pushBlock(ln);
+          continue;
+        }
+        if (/^\s*\}\s*$/.test(raw)) {
+          const blk = stack.pop();
+          if (blk) {
+            const all = [...blk.content.map((l3) => ({ ln: l3, kind: "content" })), ...blk.seps.map((l3) => ({ ln: l3, kind: "sep" }))].sort((a3, b3) => a3.ln - b3.ln);
+            const sepIdxs = all.map((x3, i4) => ({ i: i4, x: x3 })).filter((z3) => z3.x.kind === "sep").map((z3) => z3.i);
+            for (const si of sepIdxs) {
+              const sepLn = all[si].ln;
+              let hasBefore = false;
+              for (let k3 = si - 1; k3 >= 0; k3--) {
+                if (all[k3].kind === "sep")
+                  break;
+                if (all[k3].kind === "content") {
+                  hasBefore = true;
+                  break;
+                }
+              }
+              let hasAfter = false;
+              for (let k3 = si + 1; k3 < all.length; k3++) {
+                if (all[k3].kind === "sep")
+                  break;
+                if (all[k3].kind === "content") {
+                  hasAfter = true;
+                  break;
+                }
+              }
+              if (!hasBefore || !hasAfter) {
+                errors.push({
+                  line: sepLn,
+                  column: 1,
+                  severity: "error",
+                  code: "ST-CONCURRENCY-MISPLACED",
+                  message: "Concurrency separator '---' must be between regions, not at the start or end of a block.",
+                  hint: "Place '---' between two sets of state lines inside the same block."
+                });
+              }
+            }
+          }
+          continue;
+        }
+        if (stack.length > 0) {
+          if (/^\s*---\s*$/.test(raw)) {
+            top().seps.push(ln);
+            if (!has2("ST-CONCURRENCY-UNSUPPORTED", ln)) {
+              errors.push({
+                line: ln,
+                column: 1,
+                severity: "error",
+                code: "ST-CONCURRENCY-UNSUPPORTED",
+                message: "Concurrency separator '---' is not supported by Mermaid CLI in state diagrams.",
+                hint: "Remove '---' or split logic into separate composite states."
+              });
+            }
+          } else if (raw.trim() !== "")
+            top().content.push(ln);
+        }
+      }
       return errors;
     }
   });
@@ -46483,6 +47416,10 @@ function computeFixes(text, errors, level = "safe") {
       edits.push(replaceRange(text, at(e3), e3.length ?? 2, "&quot;"));
       continue;
     }
+    if (is("FL-LABEL-BACKTICK", e3)) {
+      edits.push(replaceRange(text, at(e3), e3.length ?? 1, ""));
+      continue;
+    }
     if (is("FL-LABEL-DOUBLE-IN-DOUBLE", e3)) {
       const lineText = lineTextAt(text, e3.line);
       const caret0 = Math.max(0, e3.column - 1);
@@ -46593,8 +47530,24 @@ function computeFixes(text, errors, level = "safe") {
       continue;
     }
     if (is("FL-LINK-MISSING", e3)) {
-      if (level === "all")
-        edits.push(insertAt(text, at(e3), " --> "));
+      if (level === "all") {
+        const line = e3.line;
+        const lineText = lineTextAt(text, line);
+        if (!/-->/.test(lineText)) {
+          const shapePart = "(?:\\[[^\\]]*\\]|\\([^\\)]*\\)|\\{[^}]*\\}|\\[\\[[^\\]]*\\]\\]|\\(\\([^\\)]*\\)\\))?";
+          const id = "[A-Za-z0-9_]+";
+          const re = new RegExp(`^\\s*(${id}${shapePart})\\s+(${id})`);
+          const m3 = re.exec(lineText);
+          if (m3) {
+            const before = m3[0];
+            const insertIdx = before.length - m3[2].length;
+            const col = insertIdx + 1;
+            edits.push(insertAt(text, { line, column: col }, " --> "));
+          } else {
+            edits.push(insertAt(text, at(e3), " --> "));
+          }
+        }
+      }
       continue;
     }
     if (is("FL-NODE-UNCLOSED-BRACKET", e3)) {
@@ -47213,9 +48166,13 @@ var init_graph_builder = __esm({
         this.edgeCounter = 0;
         this.subgraphs = [];
         this.currentSubgraphStack = [];
+        this.pendingLinkStyles = [];
         this.classStyles = /* @__PURE__ */ new Map();
         this.nodeStyles = /* @__PURE__ */ new Map();
         this.nodeClasses = /* @__PURE__ */ new Map();
+        this.edgeClasses = /* @__PURE__ */ new Map();
+        this.edgeStyles = /* @__PURE__ */ new Map();
+        this.nodeLinks = /* @__PURE__ */ new Map();
       }
       build(cst) {
         this.reset();
@@ -47229,6 +48186,11 @@ var init_graph_builder = __esm({
         }
         const direction = this.extractDirection(cst);
         this.processStatements(cst);
+        for (const [id, link] of this.nodeLinks.entries()) {
+          const node = this.nodes.get(id);
+          if (node)
+            node.link = link;
+        }
         return {
           nodes: Array.from(this.nodes.values()),
           edges: this.edges,
@@ -47246,6 +48208,10 @@ var init_graph_builder = __esm({
         this.classStyles.clear();
         this.nodeStyles.clear();
         this.nodeClasses.clear();
+        this.edgeClasses.clear();
+        this.edgeStyles.clear();
+        this.pendingLinkStyles = [];
+        this.nodeLinks.clear();
       }
       extractDirection(cst) {
         const dirToken = cst.children?.Direction?.[0];
@@ -47279,14 +48245,100 @@ var init_graph_builder = __esm({
             this.processClassAssign(stmt.children.classStatement[0]);
           } else if (stmt.children?.styleStatement) {
             this.processStyle(stmt.children.styleStatement[0]);
+          } else if (stmt.children?.linkStyleStatement) {
+            this.processLinkStyle(stmt.children.linkStyleStatement[0]);
+          } else if (stmt.children?.clickStatement) {
+            this.processClick(stmt.children.clickStatement[0]);
+          } else if (stmt.children?.edgeAttrStatement) {
+            this.processEdgeAttr(stmt.children.edgeAttrStatement[0]);
           }
         }
+        this.applyLinkStyles();
+      }
+      unquote(s3) {
+        if (!s3)
+          return s3;
+        if (s3.startsWith('"') && s3.endsWith('"') || s3.startsWith("'") && s3.endsWith("'"))
+          return s3.slice(1, -1);
+        return s3;
+      }
+      processClick(cst) {
+        const ch = cst.children || {};
+        const tgtTok = ch.clickTarget?.[0];
+        if (!tgtTok)
+          return;
+        const id = tgtTok.image;
+        const link = {};
+        if (ch.clickHref && ch.clickHref[0]) {
+          const hrefCh = ch.clickHref[0].children || {};
+          if (hrefCh.url && hrefCh.url[0])
+            link.href = this.unquote(hrefCh.url[0].image);
+          if (hrefCh.tooltip && hrefCh.tooltip[0])
+            link.tooltip = this.unquote(hrefCh.tooltip[0].image);
+          if (hrefCh.target && hrefCh.target[0])
+            link.target = hrefCh.target[0].image;
+        } else if (ch.clickCall && ch.clickCall[0]) {
+          const callCh = ch.clickCall[0].children || {};
+          if (callCh.fn && callCh.fn[0])
+            link.call = callCh.fn[0].image;
+          if (callCh.tooltip && callCh.tooltip[0])
+            link.tooltip = this.unquote(callCh.tooltip[0].image);
+        } else {
+          const idents = ch.Identifier || [];
+          const texts = ch.Text || [];
+          const quotes = ch.QuotedString || [];
+          const modeTok = idents.find((t3) => /^(href|call|callback)$/i.test(t3.image));
+          const mode = modeTok?.image?.toLowerCase();
+          if (mode === "href") {
+            const urlTok = quotes[0];
+            const tipTok = quotes[1];
+            const targetTok = idents.find((t3) => /^_(blank|self|parent|top)$/i.test(t3.image));
+            if (urlTok)
+              link.href = this.unquote(urlTok.image);
+            if (tipTok)
+              link.tooltip = this.unquote(tipTok.image);
+            if (targetTok)
+              link.target = targetTok.image;
+          } else if (mode === "call" || mode === "callback") {
+            const reserved = /* @__PURE__ */ new Set(["href", "call", "callback", "_blank", "_self", "_parent", "_top"]);
+            const after = idents.filter((t3) => (t3.startOffset ?? 0) > (modeTok?.startOffset ?? -1));
+            const nameTok = after.find((t3) => !reserved.has(t3.image.toLowerCase()));
+            const tstr = texts.map((t3) => t3.image).join(" ").trim();
+            link.call = nameTok ? nameTok.image + (tstr ? ` ${tstr}` : "") : tstr || void 0;
+            const tipTok = quotes[0];
+            if (tipTok)
+              link.tooltip = this.unquote(tipTok.image);
+          }
+        }
+        if (Object.keys(link).length)
+          this.nodeLinks.set(id, { ...this.nodeLinks.get(id) || {}, ...link });
       }
       processNodeStatement(stmt) {
         const groups = stmt.children?.nodeOrParallelGroup;
         const links = stmt.children?.link;
         if (!groups || groups.length === 0)
           return;
+        if ((!links || links.length === 0) && groups.length === 1) {
+          const g0 = groups[0];
+          const nodes = g0.children?.node || [];
+          if (nodes.length === 1) {
+            const n3 = nodes[0];
+            const hasAttr = !!(n3.children.attrObject && n3.children.attrObject.length);
+            const hasShape = !!n3.children?.nodeShape;
+            if (hasAttr && !hasShape) {
+              const idTok = n3.children.nodeId?.[0] || n3.children.Identifier?.[0] || void 0;
+              if (idTok) {
+                const id = idTok.image;
+                const exists = this.edges.some((e3) => e3.id === id);
+                if (exists) {
+                  const edgeAttrFake = { children: { edgeId: [{ image: id }], attrObject: n3.children.attrObject } };
+                  this.processEdgeAttr(edgeAttrFake);
+                  return;
+                }
+              }
+            }
+          }
+        }
         const sourceNodes = this.processNodeGroup(groups[0]);
         if (groups.length > 1 && links && links.length > 0) {
           const targetNodes = this.processNodeGroup(groups[1]);
@@ -47294,7 +48346,7 @@ var init_graph_builder = __esm({
           for (const source of sourceNodes) {
             for (const target of targetNodes) {
               this.edges.push({
-                id: `e${this.edgeCounter++}`,
+                id: linkInfo.edgeId || `e${this.edgeCounter++}`,
                 source,
                 target,
                 label: linkInfo.label,
@@ -47310,7 +48362,7 @@ var init_graph_builder = __esm({
             for (const source of targetNodes) {
               for (const target of nextNodes) {
                 this.edges.push({
-                  id: `e${this.edgeCounter++}`,
+                  id: nextLink.edgeId || `e${this.edgeCounter++}`,
                   source,
                   target,
                   label: nextLink.label,
@@ -47393,13 +48445,101 @@ var init_graph_builder = __esm({
           if (result.label)
             label = result.label;
         }
+        const attrNode = children.attrObject?.[0];
+        let typedShape;
+        if (attrNode && !shapeNode) {
+          typedShape = this.parseTypedAttrObject(attrNode);
+          if (typedShape.shape) {
+            const m3 = typedShape.shape;
+            if (m3 === "rect")
+              shape = "rectangle";
+            else if (m3 === "round" || m3 === "rounded")
+              shape = "round";
+            else if (m3 === "stadium")
+              shape = "stadium";
+            else if (m3 === "subroutine")
+              shape = "subroutine";
+            else if (m3 === "circle")
+              shape = "circle";
+            else if (m3 === "cylinder")
+              shape = "cylinder";
+            else if (m3 === "diamond")
+              shape = "diamond";
+            else if (m3 === "trapezoid")
+              shape = "trapezoid";
+            else if (m3 === "trapezoidAlt")
+              shape = "trapezoidAlt";
+            else if (m3 === "parallelogram" || m3 === "lean-l" || m3 === "lean-r") {
+              shape = "parallelogram";
+              typedShape.lean = m3 === "lean-l" ? "l" : m3 === "lean-r" ? "r" : void 0;
+            } else if (m3 === "hexagon")
+              shape = "hexagon";
+            else if (m3 === "icon" || m3 === "image")
+              shape = "rectangle";
+          }
+          if (typeof typedShape.label === "string" && typedShape.label.length > 0) {
+            label = typedShape.label;
+          }
+        }
         const clsTok = children.nodeClass?.[0];
         if (clsTok) {
           const set = this.nodeClasses.get(id) || /* @__PURE__ */ new Set();
           set.add(clsTok.image);
           this.nodeClasses.set(id, set);
         }
-        return { id, label, shape };
+        const out = { id, label, shape };
+        if (typedShape) {
+          const padding = typedShape.padding;
+          const cornerRadius = typedShape.cornerRadius;
+          const lean = typedShape.lean;
+          const media = typedShape.icon || typedShape.image ? { icon: typedShape.icon, image: typedShape.image } : void 0;
+          out.typed = { padding, cornerRadius, lean, media };
+        }
+        return out;
+      }
+      parseTypedAttrObject(attrNode) {
+        const ch = attrNode.children || {};
+        const pairs = ch.attrPair || [];
+        const out = {};
+        for (const p3 of pairs) {
+          const keyTok = p3.children?.attrKey?.[0];
+          if (!keyTok)
+            continue;
+          const k3 = keyTok.image;
+          const vTok = p3.children?.QuotedString?.[0] || p3.children?.Identifier?.[0] || p3.children?.NumberLiteral?.[0] || p3.children?.Text?.[0];
+          if (!vTok)
+            continue;
+          let raw = vTok.image;
+          if (raw.startsWith('"') && raw.endsWith('"') || raw.startsWith("'") && raw.endsWith("'"))
+            raw = raw.slice(1, -1);
+          switch (k3) {
+            case "shape":
+              out.shape = raw;
+              break;
+            case "label":
+              out.label = raw;
+              break;
+            case "padding": {
+              const n3 = parseFloat(raw);
+              if (Number.isFinite(n3))
+                out.padding = n3;
+              break;
+            }
+            case "cornerRadius": {
+              const n3 = parseFloat(raw);
+              if (Number.isFinite(n3))
+                out.cornerRadius = n3;
+              break;
+            }
+            case "icon":
+              out.icon = raw;
+              break;
+            case "image":
+              out.image = raw;
+              break;
+          }
+        }
+        return out;
       }
       extractShapeAndLabel(shapeNode) {
         const children = shapeNode.children;
@@ -47518,6 +48658,7 @@ var init_graph_builder = __esm({
         let label;
         let markerStart = "none";
         let markerEnd = "none";
+        const eidTok = children.edgeId?.[0];
         if (children.BiDirectionalArrow) {
           type = "arrow";
           markerStart = "arrow";
@@ -47592,7 +48733,7 @@ var init_graph_builder = __esm({
           };
           label = strip(raw);
         }
-        return { type, label, markerStart, markerEnd };
+        return { type, label, markerStart, markerEnd, edgeId: eidTok ? eidTok.image : void 0 };
       }
       processSubgraph(subgraph) {
         const children = subgraph.children;
@@ -47655,12 +48796,15 @@ var init_graph_builder = __esm({
           return;
         const classNameTok = cst.children.className?.[0];
         const className = classNameTok?.image || ids[ids.length - 1].image;
-        const nodeIds = classNameTok ? ids.slice(0, -1) : ids.slice(0, -1);
-        for (const tok of nodeIds) {
+        const targetIds = classNameTok ? ids.slice(0, -1) : ids.slice(0, -1);
+        for (const tok of targetIds) {
           const id = tok.image;
-          const set = this.nodeClasses.get(id) || /* @__PURE__ */ new Set();
-          set.add(className);
-          this.nodeClasses.set(id, set);
+          const nset = this.nodeClasses.get(id) || /* @__PURE__ */ new Set();
+          nset.add(className);
+          this.nodeClasses.set(id, nset);
+          const eset = this.edgeClasses.get(id) || /* @__PURE__ */ new Set();
+          eset.add(className);
+          this.edgeClasses.set(id, eset);
           const node = this.nodes.get(id);
           if (node) {
             node.style = { ...node.style || {}, ...this.computeNodeStyle(id) };
@@ -47706,6 +48850,121 @@ var init_graph_builder = __esm({
         }
         return props;
       }
+      processEdgeAttr(cst) {
+        const eidTok = cst.children.edgeId?.[0];
+        if (!eidTok)
+          return;
+        const id = eidTok.image;
+        const attrNode = cst.children.attrObject?.[0];
+        if (!attrNode)
+          return;
+        const ch = attrNode.children || {};
+        const pairs = ch.attrPair || [];
+        const props = {};
+        for (const p3 of pairs) {
+          const keyTok = p3.children.attrKey?.[0];
+          const vTok = p3.children.QuotedString?.[0] || p3.children.Identifier?.[0] || p3.children.NumberLiteral?.[0] || p3.children.Text?.[0];
+          if (!keyTok || !vTok)
+            continue;
+          let val = vTok.image;
+          if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'"))
+            val = val.slice(1, -1);
+          const k3 = keyTok.image;
+          if (k3 === "animate") {
+            const truthy = /^(true|1|yes|on|fast|slow)$/i.test(val);
+            if (truthy) {
+              props["animation"] = /^slow$/i.test(val) ? "dash 8s linear infinite" : /^fast$/i.test(val) ? "dash 2s linear infinite" : "dash 4s linear infinite";
+              if (!props["stroke-dasharray"])
+                props["stroke-dasharray"] = "5 5";
+            }
+          } else {
+            props[k3] = val;
+          }
+        }
+        const cur = this.edgeStyles.get(id) || {};
+        this.edgeStyles.set(id, { ...cur, ...props });
+      }
+      computeEdgeStyle(edgeId) {
+        const out = {};
+        const classes = this.edgeClasses.get(edgeId);
+        if (classes) {
+          for (const c3 of classes) {
+            const s3 = this.classStyles.get(c3);
+            if (s3)
+              Object.assign(out, this.normalizeStyle(s3));
+          }
+        }
+        const direct = this.edgeStyles.get(edgeId);
+        if (direct)
+          Object.assign(out, this.normalizeStyle(direct));
+        return out;
+      }
+      processLinkStyle(cst) {
+        const ch = cst.children || {};
+        if (ch.linkStyleIndexList && ch.linkStylePairs) {
+          const idxNode = ch.linkStyleIndexList[0];
+          const pairNode = ch.linkStylePairs[0];
+          const idxToks = (idxNode.children || {}).index || [];
+          const indices2 = idxToks.map((t3) => parseInt(t3.image, 10)).filter((n3) => Number.isFinite(n3));
+          const pairs = (pairNode.children || {}).linkStylePair || [];
+          const props2 = {};
+          for (const p3 of pairs) {
+            const pch = p3.children || {};
+            const keyTok = pch.key?.[0];
+            const vTok = pch.valueColor?.[0] || pch.valueQuoted?.[0] || pch.valueNum?.[0] || pch.valueId?.[0] || pch.valueText?.[0];
+            if (!keyTok || !vTok)
+              continue;
+            let val = vTok.image;
+            if (vTok.tokenType?.name === "QuotedString" && (val.startsWith('"') || val.startsWith("'"))) {
+              val = val.slice(1, -1);
+            }
+            props2[keyTok.image] = val;
+          }
+          this.pendingLinkStyles.push({ indices: indices2, props: props2 });
+          return;
+        }
+        const nums = cst.children?.NumberLiteral || [];
+        const indices = nums.map((n3) => parseInt(n3.image, 10)).filter((n3) => Number.isFinite(n3));
+        const props = this.collectStyleProps(cst);
+        this.pendingLinkStyles.push({ indices, props });
+      }
+      applyLinkStyles() {
+        if (!this.pendingLinkStyles.length || !this.edges.length)
+          return;
+        const normalize = (s3) => {
+          const out = {};
+          for (const [kRaw, vRaw] of Object.entries(s3)) {
+            const k3 = kRaw.trim().toLowerCase();
+            const v3 = vRaw.trim();
+            if (k3 === "stroke")
+              out.stroke = v3;
+            else if (k3 === "stroke-width") {
+              const num = parseFloat(v3);
+              if (!Number.isNaN(num))
+                out.strokeWidth = num;
+            } else if (k3 === "opacity" || k3 === "stroke-opacity") {
+              const num = parseFloat(v3);
+              if (!Number.isNaN(num))
+                out.strokeOpacity = num;
+            } else if (k3 === "stroke-dasharray")
+              out.dasharray = v3;
+          }
+          return out;
+        };
+        for (const cmd of this.pendingLinkStyles) {
+          const style = normalize(cmd.props);
+          for (const idx of cmd.indices) {
+            if (idx >= 0 && idx < this.edges.length) {
+              const e3 = this.edges[idx];
+              e3.style = { ...e3.style || {}, stroke: style.stroke ?? e3.style?.stroke, strokeWidth: style.strokeWidth ?? e3.style?.strokeWidth, strokeOpacity: style.strokeOpacity ?? e3.style?.strokeOpacity };
+              if (style.dasharray)
+                e3.dasharray = style.dasharray;
+              if (style.animation)
+                e3.animation = style.animation;
+            }
+          }
+        }
+      }
       computeNodeStyle(nodeId) {
         const out = {};
         const classes = this.nodeClasses.get(nodeId);
@@ -55457,8 +56716,10 @@ var init_layout = __esm({
           marginy: 20
         };
         if (hasClusters && (dir === "LR" || dir === "RL")) {
-          graphConfig.ranker = "longest-path";
+          graphConfig.ranker = "network-simplex";
           graphConfig.acyclicer = "greedy";
+          nodesep += 40;
+          ranksep = Math.max(30, ranksep - 20);
         }
         if (hasClusters) {
           graphConfig.compound = true;
@@ -55471,7 +56732,9 @@ var init_layout = __esm({
           }
         }
         for (const node of graph.nodes) {
-          const dimensions = this.calculateNodeDimensions(node.label, node.shape);
+          const providedW = node.width;
+          const providedH = node.height;
+          const dimensions = providedW && providedH ? { width: providedW, height: providedH } : this.calculateNodeDimensions(node.label, node.shape);
           g3.setNode(node.id, {
             width: dimensions.width,
             height: dimensions.height,
@@ -55595,7 +56858,7 @@ var init_layout = __esm({
                 const inX = end.x + (rankdir === "LR" ? -PAD : PAD);
                 const startOut = { x: srcSg ? outX : start.x, y: start.y };
                 const endPre = { x: dstSg ? inX : end.x, y: end.y };
-                const alpha = 0.68;
+                const alpha = 0.72;
                 const midX = startOut.x + (endPre.x - startOut.x) * alpha;
                 const m1 = { x: midX, y: startOut.y };
                 const m22 = { x: midX, y: endPre.y };
@@ -55792,6 +57055,11 @@ function buildSharedCss(opts = {}) {
     .edge-path { stroke: ${edgeStroke}; stroke-width: 2px; fill: none; }
     .edge-label-bg { fill: rgba(232,232,232, 0.8); opacity: 0.5; }
     .edge-label-text { fill: #333; font-family: ${fontFamily}; font-size: ${Math.max(10, fontSize - 2)}px; }
+    .edge-marker { stroke: ${edgeStroke}; }
+    .edge-marker-fill { fill: ${edgeStroke}; }
+
+    /* Basic stroke dash animation used by flowchart link animation presets */
+    @keyframes dash { to { stroke-dashoffset: -1000; } }
 
     /* Cluster (flowchart + sequence blocks) */
     .cluster-bg { fill: #ffffde; }
@@ -55806,15 +57074,77 @@ function buildSharedCss(opts = {}) {
     /* Sequence-specific add-ons (safe for flowcharts too) */
     .actor-rect { fill: #eaeaea; stroke: #666; stroke-width: 1.5px; }
     .actor-label { fill: #111; font-family: ${fontFamily}; font-size: 16px; }
-    .lifeline { stroke: #999; stroke-width: 0.5px; }
+    .lifeline { stroke: #999; stroke-width: 1px; }
     .activation { fill: #f4f4f4; stroke: #666; stroke-width: 1px; }
     .msg-line { stroke: #333; stroke-width: 1.5px; fill: none; }
     .msg-line.dotted { stroke-dasharray: 2 2; }
     .msg-line.thick { stroke-width: 3px; }
+    .openhead { fill: none; stroke: #333; stroke-width: 1.5px; }
+    .crosshead path { stroke: #333; stroke-width: 1.5px; }
     .msg-label { fill: #333; font-family: ${fontFamily}; font-size: 12px; dominant-baseline: middle; }
     .msg-label-bg { fill: #ffffff; stroke: #cccccc; stroke-width: 1px; rx: 3; }
+
+    /* State overlays */
+    .lane-divider { stroke: #aaaaaa; stroke-width: 1px; stroke-dasharray: 4 3; }
+    .end-double { stroke: #3f3f3f; stroke-width: 1px; fill: none; }
   `;
 }
+function applyFlowLikeTheme(svg, theme) {
+  if (!theme)
+    return svg;
+  let out = svg;
+  if (theme.nodeBkg || theme.nodeBorder) {
+    out = out.replace(/\.node-shape\s*\{[^}]*\}/, (m3) => {
+      let rule = m3;
+      if (theme.nodeBkg)
+        rule = rule.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.nodeBkg)};`);
+      if (theme.nodeBorder)
+        rule = rule.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.nodeBorder)};`);
+      return rule;
+    });
+  }
+  if (theme.nodeTextColor) {
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.nodeTextColor)};`));
+    out = out.replace(/\.edge-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.nodeTextColor)};`));
+  }
+  if (theme.edgeLabelTextColor) {
+    const c3 = String(theme.edgeLabelTextColor);
+    out = out.replace(/\.edge-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${c3};`));
+  }
+  if (theme.lineColor) {
+    out = out.replace(/\.edge-path\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lineColor)};`));
+  }
+  if (theme.arrowheadColor) {
+    out = out.replace(/\.edge-marker\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
+    out = out.replace(/\.edge-marker-fill\s*\{[^}]*\}/, (m3) => m3.includes("fill:") ? m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.arrowheadColor)};`) : m3.replace(/\}/, ` fill: ${String(theme.arrowheadColor)}; }`));
+    out = out.replace(/\.openhead\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
+    out = out.replace(/\.crosshead path\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
+  }
+  if (theme.clusterBkg)
+    out = out.replace(/\.cluster-bg\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterBkg)};`));
+  if (theme.clusterBorder)
+    out = out.replace(/\.cluster-border\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.clusterBorder)};`));
+  if (theme.clusterTextColor)
+    out = out.replace(/\.cluster-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterTextColor)};`));
+  if (theme.clusterTitleBg || theme.clusterTitleBackground) {
+    const c3 = String(theme.clusterTitleBg || theme.clusterTitleBackground);
+    out = out.replace(/\.cluster-title-bg\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${c3};`));
+  }
+  if (theme.fontFamily) {
+    const f3 = String(theme.fontFamily);
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/font-family:\s*[^;]+;/, `font-family: ${f3};`));
+    out = out.replace(/\.edge-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/font-family:\s*[^;]+;/, `font-family: ${f3};`));
+    out = out.replace(/\.note-text\s*\{[^}]*\}/, (m3) => m3.replace(/font-family:\s*[^;]+;/, `font-family: ${f3};`));
+  }
+  if (theme.fontSize) {
+    const s3 = String(theme.fontSize);
+    out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/font-size:\s*[^;]+;/, `font-size: ${s3}px;`));
+    const sub = Math.max(10, Number(theme.fontSize) - 2);
+    out = out.replace(/\.edge-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/font-size:\s*[^;]+;/, `font-size: ${sub}px;`));
+    out = out.replace(/\.note-text\s*\{[^}]*\}/, (m3) => m3.replace(/font-size:\s*[^;]+;/, `font-size: ${sub}px;`));
+  }
+  return out;
+}
 var init_styles = __esm({
   "node_modules/@probelabs/maid/out/renderer/styles.js"() {
   }
@@ -55998,6 +57328,8 @@ var init_svg_generator = __esm({
           };
           const bgs = [];
           for (const sg of order) {
+            if (sg.id && sg.id.includes("__lane"))
+              continue;
             const x3 = sg.x + padX;
             const y2 = sg.y + padY;
             bgs.push(blockBackground(x3, y2, sg.width, sg.height, 0));
@@ -56035,7 +57367,7 @@ var init_svg_generator = __esm({
           edgeStroke: this.arrowStroke
         });
         const css = `<style>${sharedCss}</style>`;
-        return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+        return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
   ${bg}
   ${css}
   ${elements.join("\n  ")}
@@ -56088,13 +57420,17 @@ var init_svg_generator = __esm({
         const stroke = node.style?.stroke ?? void 0;
         const fill = node.style?.fill ?? void 0;
         const styleAttr = this.buildNodeStyleAttrs({ stroke, strokeWidth, fill });
+        const typed = node.typed;
+        const innerPad = Math.max(0, typed?.padding ?? 10);
         switch (node.shape) {
           case "rectangle":
             shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />`;
             break;
-          case "round":
-            shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="5" ry="5" />`;
+          case "round": {
+            const rx = Math.max(0, typed?.cornerRadius ?? 5);
+            shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="${rx}" ry="${rx}" />`;
             break;
+          }
           case "stadium":
             const radius = node.height / 2;
             shape = `<rect class="node-shape" ${styleAttr} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="${radius}" ry="${radius}" />`;
@@ -56138,16 +57474,18 @@ var init_svg_generator = __esm({
           }
           case "parallelogram": {
             const skew = node.width * 0.15;
-            const points = [
+            const leftLean = typed?.lean === "l";
+            const points = (leftLean ? [
+              `${x3},${y2}`,
+              `${x3 + node.width - skew},${y2}`,
+              `${x3 + node.width},${y2 + node.height}`,
+              `${x3 + skew},${y2 + node.height}`
+            ] : [
               `${x3 + skew},${y2}`,
-              // top-left
               `${x3 + node.width},${y2}`,
-              // top-right
               `${x3 + node.width - skew},${y2 + node.height}`,
-              // bottom-right
               `${x3},${y2 + node.height}`
-              // bottom-left
-            ].join(" ");
+            ]).join(" ");
             shape = `<polygon class="node-shape" ${styleAttr} points="${points}" />`;
             break;
           }
@@ -56217,11 +57555,33 @@ var init_svg_generator = __esm({
             const s3 = this.buildNodeStyleAttrs({ stroke, strokeWidth, fill });
             shape = `<rect ${s3} x="${x3}" y="${y2}" width="${node.width}" height="${node.height}" rx="0" ry="0" />`;
         }
-        const text = this.generateWrappedText(node.label, cx, labelCenterY, node.width - 20);
-        return `<g id="${node.id}">
+        const text = this.generateWrappedText(node.label, cx, labelCenterY, node.width - innerPad * 2);
+        let media = "";
+        if (typed?.media?.image) {
+          const iw = Math.min(24, Math.max(12, node.height - 10));
+          const ih = iw;
+          const ix = x3 + 4;
+          const iy = y2 + (node.height - ih) / 2;
+          media = `<image xlink:href="${this.escapeXml(typed.media.image)}" x="${ix}" y="${iy}" width="${iw}" height="${ih}" />`;
+        }
+        const baseGroup = `<g id="${node.id}">
     ${shape}
+    ${media}
     ${text}
   </g>`;
+        const link = node.link;
+        if (link && link.href) {
+          const tt = link.tooltip ? `<title>${this.escapeXml(link.tooltip)}</title>` : "";
+          const tgt = link.target ? ` target="${this.escapeXml(link.target)}" rel="noopener noreferrer"` : "";
+          return `<a xlink:href="${this.escapeXml(link.href)}"${tgt} class="node-link">${tt}${baseGroup}</a>`;
+        }
+        if (link && link.tooltip) {
+          return `<g class="node-call">
+<title>${this.escapeXml(link.tooltip)}</title>
+${baseGroup}
+</g>`;
+        }
+        return baseGroup;
       }
       generateWrappedText(text, x3, y2, maxWidth) {
         if (text.includes("<")) {
@@ -56459,16 +57819,31 @@ var init_svg_generator = __esm({
         }
         const pathData = pathParts.join(" ");
         let edgeElement = `<path class="edge-path" d="${pathData}" stroke-linecap="round" stroke-linejoin="round"`;
+        const styleStroke = edge.style?.stroke;
+        const styleStrokeWidth = edge.style?.strokeWidth;
+        const styleStrokeOpacity = edge.style?.strokeOpacity;
+        if (edge.dasharray)
+          strokeDasharray = String(edge.dasharray);
+        const anim = edge.animation;
+        if (!strokeDasharray && anim)
+          strokeDasharray = "5 5";
         if (strokeDasharray) {
           edgeElement += ` stroke-dasharray="${strokeDasharray}"`;
         }
-        const startMarkUrl = mStart === "arrow" ? "url(#arrow)" : mStart === "circle" ? "url(#circle-marker)" : mStart === "cross" ? "url(#cross-marker)" : "";
-        const endMarkUrl = mEnd === "arrow" ? "url(#arrow)" : mEnd === "circle" ? "url(#circle-marker)" : mEnd === "cross" ? "url(#cross-marker)" : markerEnd || "";
-        if (startMarkUrl && mStart !== "arrow")
-          edgeElement += ` marker-start="${startMarkUrl}"`;
-        if (endMarkUrl && mEnd !== "arrow")
-          edgeElement += ` marker-end="${endMarkUrl}"`;
-        edgeElement += " />";
+        if (styleStrokeWidth != null) {
+          edgeElement += ` stroke-width="${styleStrokeWidth}"`;
+        } else {
+          if (strokeWidth && strokeWidth !== 1.5)
+            edgeElement += ` stroke-width="${strokeWidth}"`;
+        }
+        if (styleStrokeOpacity != null) {
+          edgeElement += ` stroke-opacity="${styleStrokeOpacity}"`;
+        }
+        if (styleStroke) {
+          edgeElement += ` stroke="${styleStroke}"`;
+        }
+        const inlineAnim = anim ? ` style="animation:${anim}"` : "";
+        edgeElement += inlineAnim + " />";
         if (edge.label) {
           const pos = this.pointAtRatio(points, 0.55);
           const text = this.escapeXml(edge.label);
@@ -56489,14 +57864,15 @@ var init_svg_generator = __esm({
           const uyl = vyl / vlenl;
           const nxl = -uyl;
           const nyl = uxl;
-          const triLenL = 8;
-          const triWL = 6;
+          const ow = styleStrokeWidth != null ? styleStrokeWidth : strokeWidth;
+          const triLenL = Math.max(6, Math.min(14, 6 + (ow - 1.5) * 3));
+          const triWL = Math.max(5, Math.min(12, 5 + (ow - 1.5) * 2.5));
           const p1xL = boundaryEnd.x, p1yL = boundaryEnd.y;
           const baseXL = boundaryEnd.x - uxl * triLenL;
           const baseYL = boundaryEnd.y - uyl * triLenL;
           const p2xL = baseXL + nxl * (triWL / 2), p2yL = baseYL + nyl * (triWL / 2);
           const p3xL = baseXL - nxl * (triWL / 2), p3yL = baseYL - nyl * (triWL / 2);
-          overlay2 += triangleAtEnd(prevEndL, boundaryEnd, this.arrowStroke);
+          overlay2 += triangleAtEnd(prevEndL, boundaryEnd, styleStroke || this.arrowStroke, triLenL, triWL);
           if (mStart === "arrow" && points.length >= 2) {
             const firstLeg = points[1];
             const svx = boundaryStart.x - firstLeg.x;
@@ -56508,7 +57884,7 @@ var init_svg_generator = __esm({
             const sny = sux;
             const sbaseX = boundaryStart.x - sux * triLenL;
             const sbaseY = boundaryStart.y - suy * triLenL;
-            overlay2 += triangleAtStart(boundaryStart, firstLeg, this.arrowStroke);
+            overlay2 += triangleAtStart(boundaryStart, firstLeg, styleStroke || this.arrowStroke, triLenL, triWL);
           }
           const pathGroup = `<g>
     ${edgeElement}
@@ -56527,15 +57903,16 @@ var init_svg_generator = __esm({
         const uy = vy / vlen;
         const nx = -uy;
         const ny = ux;
-        const triLen = 8;
-        const triW = 6;
+        const ow2 = styleStrokeWidth != null ? styleStrokeWidth : strokeWidth;
+        const triLen = Math.max(6, Math.min(14, 6 + (ow2 - 1.5) * 3));
+        const triW = Math.max(5, Math.min(12, 5 + (ow2 - 1.5) * 2.5));
         const p1x = boundaryEnd.x, p1y = boundaryEnd.y;
         const baseX = boundaryEnd.x - ux * triLen;
         const baseY = boundaryEnd.y - uy * triLen;
         const p2x = baseX + nx * (triW / 2), p2y = baseY + ny * (triW / 2);
         const p3x = baseX - nx * (triW / 2), p3y = baseY - ny * (triW / 2);
         if (mEnd === "arrow")
-          overlay += triangleAtEnd(prevEnd, boundaryEnd, this.arrowStroke);
+          overlay += triangleAtEnd(prevEnd, boundaryEnd, styleStroke || this.arrowStroke, triLen, triW);
         if (mStart === "arrow" && points.length >= 2) {
           const firstLeg = points[1];
           const svx = boundaryStart.x - firstLeg.x;
@@ -56545,8 +57922,19 @@ var init_svg_generator = __esm({
           const suy = svy / slen;
           const snx = -suy;
           const sny = sux;
-          overlay += triangleAtStart(boundaryStart, firstLeg, this.arrowStroke);
-        }
+          overlay += triangleAtStart(boundaryStart, firstLeg, styleStroke || this.arrowStroke, triLen, triW);
+        }
+        const owStroke = styleStroke || this.arrowStroke;
+        const addCircle = (at2) => `<circle cx="${at2.x}" cy="${at2.y}" r="4.5" fill="none" stroke="${owStroke}" stroke-width="${ow2}" />`;
+        const addCross = (at2) => `<g transform="translate(${at2.x},${at2.y})"><path d="M -4 -4 L 4 4" stroke="${owStroke}" stroke-width="${ow2}"/><path d="M -4 4 L 4 -4" stroke="${owStroke}" stroke-width="${ow2}"/></g>`;
+        if (mEnd === "circle")
+          overlay += addCircle(boundaryEnd);
+        if (mEnd === "cross")
+          overlay += addCross(boundaryEnd);
+        if (mStart === "circle")
+          overlay += addCircle(boundaryStart);
+        if (mStart === "cross")
+          overlay += addCross(boundaryStart);
         if (overlay) {
           const grouped = `<g>${edgeElement}
 ${overlay}</g>`;
@@ -56672,6 +58060,16 @@ ${overlay}</g>`;
           { x: node.x, y: node.y + node.height }
         ];
         switch (shape) {
+          case "round": {
+            const poly = [
+              { x: node.x, y: node.y },
+              { x: node.x + node.width, y: node.y },
+              { x: node.x + node.width, y: node.y + node.height },
+              { x: node.x, y: node.y + node.height }
+            ];
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
+          }
           case "circle": {
             const cx = node.x + node.width / 2;
             const cy = node.y + node.height / 2;
@@ -56682,7 +58080,8 @@ ${overlay}</g>`;
             const cx = node.x + node.width / 2;
             const cy = node.y + node.height / 2;
             const poly = [{ x: cx, y: node.y }, { x: node.x + node.width, y: cy }, { x: cx, y: node.y + node.height }, { x: node.x, y: cy }];
-            return this.linePolygonIntersection(p1, p22, poly);
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
           case "hexagon": {
             const s3 = Math.max(10, node.width * 0.2);
@@ -56694,7 +58093,8 @@ ${overlay}</g>`;
               { x: node.x + s3, y: node.y + node.height },
               { x: node.x, y: node.y + node.height / 2 }
             ];
-            return this.linePolygonIntersection(p1, p22, poly);
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
           case "parallelogram": {
             const o3 = Math.min(node.width * 0.25, node.height * 0.6);
@@ -56704,7 +58104,8 @@ ${overlay}</g>`;
               { x: node.x + node.width - o3, y: node.y + node.height },
               { x: node.x, y: node.y + node.height }
             ];
-            return this.linePolygonIntersection(p1, p22, poly);
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
           case "trapezoid": {
             const o3 = Math.min(node.width * 0.2, node.height * 0.5);
@@ -56714,7 +58115,8 @@ ${overlay}</g>`;
               { x: node.x + node.width, y: node.y + node.height },
               { x: node.x, y: node.y + node.height }
             ];
-            return this.linePolygonIntersection(p1, p22, poly);
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
           case "trapezoidAlt": {
             const o3 = Math.min(node.width * 0.2, node.height * 0.5);
@@ -56724,7 +58126,8 @@ ${overlay}</g>`;
               { x: node.x + node.width - o3, y: node.y + node.height },
               { x: node.x + o3, y: node.y + node.height }
             ];
-            return this.linePolygonIntersection(p1, p22, poly);
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
           case "stadium": {
             const r3 = Math.min(node.height / 2, node.width / 2);
@@ -56752,10 +58155,13 @@ ${overlay}</g>`;
                 }
               return best;
             };
-            return pick(left, right);
+            const hit = pick(left, right);
+            return hit || this.nearestPointOnPolygon(p22, rect);
           }
           default: {
-            return this.linePolygonIntersection(p1, p22, rectPoly());
+            const poly = rectPoly();
+            const hit = this.linePolygonIntersection(p1, p22, poly);
+            return hit || this.nearestPointOnPolygon(p22, poly);
           }
         }
       }
@@ -56795,6 +58201,30 @@ ${overlay}</g>`;
         }
         return best;
       }
+      // Fallback helpers when lines are colinear or miss due to smoothing
+      nearestPointOnSegment(p3, a3, b3) {
+        const abx = b3.x - a3.x, aby = b3.y - a3.y;
+        const ab2 = abx * abx + aby * aby || 1;
+        const apx = p3.x - a3.x, apy = p3.y - a3.y;
+        let t3 = (apx * abx + apy * aby) / ab2;
+        t3 = Math.max(0, Math.min(1, t3));
+        return { x: a3.x + abx * t3, y: a3.y + aby * t3 };
+      }
+      nearestPointOnPolygon(to, poly) {
+        let best = poly[0];
+        let bestD = Infinity;
+        for (let i3 = 0; i3 < poly.length; i3++) {
+          const a3 = poly[i3];
+          const b3 = poly[(i3 + 1) % poly.length];
+          const p3 = this.nearestPointOnSegment(to, a3, b3);
+          const d3 = (p3.x - to.x) * (p3.x - to.x) + (p3.y - to.y) * (p3.y - to.y);
+          if (d3 < bestD) {
+            bestD = d3;
+            best = p3;
+          }
+        }
+        return { x: best.x, y: best.y };
+      }
       segmentIntersection(p3, p22, q3, q22) {
         const r3 = { x: p22.x - p3.x, y: p22.y - p3.y };
         const s3 = { x: q22.x - q3.x, y: q22.y - q3.y };
@@ -57049,16 +58479,15 @@ var init_pie_renderer = __esm({
   }
 });
 
-// node_modules/@probelabs/maid/out/renderer/sequence-builder.js
+// node_modules/@probelabs/maid/out/diagrams/sequence/cst-utils.js
 function textFromTokens(tokens) {
   if (!tokens || tokens.length === 0)
     return "";
   const parts = [];
   for (const t3 of tokens) {
-    const img = t3.image;
-    if (!img)
-      continue;
-    if (t3.tokenType && t3.tokenType.name === "QuotedString") {
+    const img = t3.image ?? "";
+    const name14 = t3.tokenType?.name;
+    if (name14 === "QuotedString") {
       if (img.startsWith('"') && img.endsWith('"'))
         parts.push(img.slice(1, -1));
       else if (img.startsWith("'") && img.endsWith("'"))
@@ -57072,6 +58501,8 @@ function textFromTokens(tokens) {
   return parts.join(" ").replace(/\s+/g, " ").trim();
 }
 function actorRefToText(refCst) {
+  if (!refCst)
+    return "";
   const ch = refCst.children || {};
   const toks = [];
   ["Identifier", "QuotedString", "NumberLiteral", "Text"].forEach((k3) => {
@@ -57096,39 +58527,20 @@ function lineRemainderToText(lineRem) {
     "Comma",
     "Colon",
     "LParen",
-    "RParen",
-    "AndKeyword",
-    "ElseKeyword",
-    "OptKeyword",
-    "OptionKeyword",
-    "LoopKeyword",
-    "ParKeyword",
-    "RectKeyword",
-    "CriticalKeyword",
-    "BreakKeyword",
-    "BoxKeyword",
-    "EndKeyword",
-    "NoteKeyword",
-    "LeftKeyword",
-    "RightKeyword",
-    "OverKeyword",
-    "OfKeyword",
-    "AutonumberKeyword",
-    "OffKeyword",
-    "LinkKeyword",
-    "LinksKeyword",
-    "CreateKeyword",
-    "DestroyKeyword",
-    "ParticipantKeyword",
-    "ActorKeyword",
-    "ActivateKeyword",
-    "DeactivateKeyword"
+    "RParen"
   ];
   for (const k3 of order)
     ch[k3]?.forEach((t3) => toks.push(t3));
   toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
-  return textFromTokens(toks) || void 0;
+  const txt = textFromTokens(toks);
+  return txt || void 0;
 }
+var init_cst_utils = __esm({
+  "node_modules/@probelabs/maid/out/diagrams/sequence/cst-utils.js"() {
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/sequence-builder.js
 function canonicalId(raw) {
   const t3 = raw.trim().replace(/\s+/g, "_");
   return t3;
@@ -57175,11 +58587,26 @@ function buildSequenceModel(text) {
   const byDisplay = /* @__PURE__ */ new Map();
   const events = [];
   let autonumber = { on: false };
+  let title;
+  let accTitle;
+  let accDescr;
   const diagramChildren = cst.children || {};
   const lines = diagramChildren.line || [];
   const openBlocks = [];
   function processLineNode(ln) {
     const ch = ln.children || {};
+    if (ch.metaStmt) {
+      const m3 = ch.metaStmt[0];
+      const mch = m3.children || {};
+      const value = lineRemainderToText(mch.lineRemainder?.[0]) || "";
+      if (mch.TitleKeyword)
+        title = value;
+      if (mch.AccTitleKeyword)
+        accTitle = value;
+      if (mch.AccDescrKeyword)
+        accDescr = value;
+      return;
+    }
     if (ch.participantDecl) {
       const decl = ch.participantDecl[0];
       const dch = decl.children || {};
@@ -57278,8 +58705,8 @@ function buildSequenceModel(text) {
         handledBlock = true;
         const bnode = ch[spec.key][0];
         const bch = bnode.children || {};
-        const title = lineRemainderToText(bch.lineRemainder?.[0]);
-        const block = { type: spec.type, title, branches: spec.branchKeys ? [] : void 0 };
+        const title2 = lineRemainderToText(bch.lineRemainder?.[0]);
+        const block = { type: spec.type, title: title2, branches: spec.branchKeys ? [] : void 0 };
         openBlocks.push(block);
         events.push({ kind: "block-start", block });
         if (spec.branchKeys) {
@@ -57290,8 +58717,8 @@ function buildSequenceModel(text) {
           if (branchTokArr && branchTokArr.length) {
             const lr = (lrArr || []).slice(1);
             for (let i3 = 0; i3 < branchTokArr.length; i3++) {
-              const title2 = lr[i3] ? lineRemainderToText(lr[i3]) : void 0;
-              const br = { kind: spec.branchKeys[0].kind, title: title2 };
+              const title22 = lr[i3] ? lineRemainderToText(lr[i3]) : void 0;
+              const br = { kind: spec.branchKeys[0].kind, title: title22 };
               block.branches.push(br);
               events.push({ kind: "block-branch", block, branch: br });
             }
@@ -57351,13 +58778,17 @@ function buildSequenceModel(text) {
   return {
     participants: Array.from(participantsMap.values()),
     events,
-    autonumber: autonumber.on === true || autonumber.on === false ? autonumber : { on: false }
+    autonumber: autonumber.on === true || autonumber.on === false ? autonumber : { on: false },
+    title,
+    accTitle,
+    accDescr
   };
 }
 var init_sequence_builder = __esm({
   "node_modules/@probelabs/maid/out/renderer/sequence-builder.js"() {
     init_lexer4();
     init_parser4();
+    init_cst_utils();
   }
 });
 
@@ -57453,7 +58884,7 @@ function layoutSequence(model) {
     if (start != null) {
       const p3 = col.get(actor);
       if (p3) {
-        activations.push({ actor, x: p3.x + p3.width / 2 - 4, y: yForRow(start) - ROW_H / 2, width: 8, height: yForRow(r3) - yForRow(start) });
+        activations.push({ actor, x: p3.x + p3.width / 2 - 3, y: yForRow(start) - ROW_H / 2, width: 6, height: yForRow(r3) - yForRow(start) });
       }
     }
     actStack.set(actor, arr);
@@ -57563,7 +58994,7 @@ function layoutSequence(model) {
       const start = arr.pop();
       const p3 = col.get(actor);
       if (p3)
-        activations.push({ actor, x: p3.x + p3.width / 2 - 4, y: yForRow(start) - ROW_H / 2, width: 8, height: yForRow(lastRow) - yForRow(start) });
+        activations.push({ actor, x: p3.x + p3.width / 2 - 3, y: yForRow(start) - ROW_H / 2, width: 6, height: yForRow(lastRow) - yForRow(start) });
     }
   }
   return { width, height, participants, lifelines, messages, notes, blocks, activations };
@@ -57575,14 +59006,14 @@ var init_sequence_layout = __esm({
     MARGIN_X = 24;
     MARGIN_Y = 24;
     ACTOR_FONT_SIZE = 16;
-    ACTOR_H = 32;
+    ACTOR_H = 30;
     LIFELINE_GAP = 4;
     ACTOR_PAD_X = 12;
     COL_MIN = 110;
     ROW_H = 36;
     NOTE_W = 160;
     NOTE_PAD = 8;
-    BLOCK_PAD = 8;
+    BLOCK_PAD = 12;
     TITLE_EXTRA_TOP = 12;
   }
 });
@@ -57602,6 +59033,18 @@ function renderSequence(model, opts = {}) {
     edgeStroke: "#555555"
   });
   svgParts.push(`  <style>${sharedCss}</style>`);
+  const accTitle = model.accTitle || model.title || void 0;
+  const accDesc = model.accDescr || void 0;
+  if (accTitle)
+    svgParts.push(`  <title>${escapeXml(accTitle)}</title>`);
+  if (accDesc)
+    svgParts.push(`  <desc>${escapeXml(accDesc)}</desc>`);
+  if (model.title) {
+    const t3 = escapeXml(model.title);
+    const tW = Math.max(20, measureText(model.title, 16));
+    const xMid = width / 2;
+    svgParts.push(`  <text class="node-label" x="${xMid}" y="0" text-anchor="middle" font-size="16">${t3}</text>`);
+  }
   for (const p3 of layout.participants)
     drawParticipant(svgParts, p3);
   for (const b3 of layout.blocks)
@@ -57625,14 +59068,14 @@ function renderSequence(model, opts = {}) {
   for (const b3 of layout.blocks) {
     const title = b3.title ? `${b3.type}: ${b3.title}` : b3.type;
     const branches = (b3.branches || []).map((br) => ({ y: br.y, title: br.title }));
-    svgParts.push(blockOverlay(b3.x, b3.y, b3.width, b3.height, title, branches, 0, "left", "left", 0));
+    svgParts.push(blockOverlay(b3.x, b3.y, b3.width, b3.height, title, branches.map((br) => ({ ...br, y: br.y + 0.5 })), 8, "left", "left", 0));
   }
   for (const p3 of layout.participants)
     drawParticipantBottom(svgParts, p3, layout);
   svgParts.push("</svg>");
   let svg = svgParts.join("\n");
   if (opts.theme)
-    svg = applySequenceTheme(svg, opts.theme);
+    svg = applySequenceTheme(applyFlowLikeTheme(svg, opts.theme), opts.theme);
   return svg;
 }
 function drawParticipant(out, p3) {
@@ -57656,9 +59099,9 @@ function drawMessage(out, m3) {
   const start = { x: x1, y: y2 };
   const end = { x: x22, y: y2 };
   if (m3.endMarker === "arrow")
-    out.push("  " + triangleAtEnd(start, end));
+    out.push("  " + triangleAtEnd(start, end, void 0, 9, 7));
   if (m3.startMarker === "arrow")
-    out.push("  " + triangleAtStart(start, end));
+    out.push("  " + triangleAtStart(start, end, void 0, 9, 7));
   if (m3.endMarker === "open")
     out.push(`  <circle class="openhead" cx="${x22}" cy="${y2}" r="4" />`);
   if (m3.startMarker === "open")
@@ -57682,8 +59125,8 @@ function drawMessageLabel(out, m3, label, _counter) {
   const h3 = 16;
   const w3 = Math.max(20, measureText(label, 12) + 10);
   const x3 = xMid - w3 / 2;
-  const y2 = m3.y - 10 - h3 / 2;
-  out.push(`  <rect class="msg-label-bg" x="${x3}" y="${y2}" width="${w3}" height="${h3}" rx="0"/>`);
+  const y2 = m3.y - 14 - h3 / 2;
+  out.push(`  <rect class="msg-label-bg" x="${x3}" y="${y2}" width="${w3}" height="${h3}" rx="3"/>`);
   out.push(`  <text class="msg-label" x="${xMid}" y="${y2 + h3 / 2}" text-anchor="middle">${escapeXml(label)}</text>`);
 }
 function drawNote(out, n3) {
@@ -57694,18 +59137,12 @@ function drawNote(out, n3) {
 }
 function applySequenceTheme(svg, theme) {
   let out = svg;
-  if (theme.actorBkg)
-    out = out.replace(/\.actor-rect\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.actorBkg)};`));
-  if (theme.actorBorder)
-    out = out.replace(/\.actor-rect\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.actorBorder)};`));
-  if (theme.actorTextColor)
-    out = out.replace(/\.actor-label\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.actorTextColor)};`));
   if (theme.lifelineColor)
     out = out.replace(/\.lifeline\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lifelineColor)};`));
   if (theme.lineColor)
     out = out.replace(/\.msg-line\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.lineColor)};`));
   if (theme.arrowheadColor) {
-    out = out.replace(/\.arrowhead\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.arrowheadColor)};`));
+    out = out.replace(/(<path d=\"M[0-9.,\s-]+Z\" fill=\")[^\"]+(\")/g, (_m2, p1, p22) => `${p1}${String(theme.arrowheadColor)}${p22}`);
     out = out.replace(/\.openhead\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
     out = out.replace(/\.crosshead\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.arrowheadColor)};`));
   }
@@ -57731,6 +59168,329 @@ var init_sequence_renderer = __esm({
   }
 });
 
+// node_modules/@probelabs/maid/out/renderer/state-builder.js
+function textFromTokens2(tokens) {
+  if (!tokens || tokens.length === 0)
+    return "";
+  const parts = [];
+  for (const t3 of tokens) {
+    const img = t3.image ?? "";
+    if (t3.tokenType && t3.tokenType.name === "QuotedString") {
+      if (img.startsWith('"') && img.endsWith('"'))
+        parts.push(img.slice(1, -1));
+      else if (img.startsWith("'") && img.endsWith("'"))
+        parts.push(img.slice(1, -1));
+      else
+        parts.push(img);
+    } else {
+      parts.push(img);
+    }
+  }
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function actorRefToId(ref, ctx = {}) {
+  if (!ref)
+    return { id: "", kind: "simple" };
+  const ch = ref.children || {};
+  if (ch.Start) {
+    const kind = ctx.isTarget ? "end" : "start";
+    return { id: `__${kind}_${ch.Start[0].startOffset ?? 0}`, kind };
+  }
+  if (ch.HistoryDeep)
+    return { id: `__histdeep_${ch.HistoryDeep[0].startOffset ?? 0}`, label: "H*", kind: "history-deep" };
+  if (ch.HistoryShallow)
+    return { id: `__hist_${ch.HistoryShallow[0].startOffset ?? 0}`, label: "H", kind: "history" };
+  let special;
+  if (ch.AngleAngleOpen && ch.Identifier && ch.AngleAngleClose) {
+    const k3 = String(ch.Identifier[0].image).toLowerCase();
+    if (k3 === "choice")
+      special = "choice";
+    else if (k3 === "fork")
+      special = "fork";
+    else if (k3 === "join")
+      special = "join";
+  }
+  const toks = [];
+  ch.Identifier?.forEach((t3) => toks.push(t3));
+  ch.QuotedString?.forEach((t3) => toks.push(t3));
+  toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+  const txt = textFromTokens2(toks) || "";
+  const id = txt.trim().replace(/\s+/g, "_");
+  return { id, label: txt, kind: special || "simple" };
+}
+function buildStateModel(text) {
+  const { tokens } = tokenize5(text);
+  parserInstance5.input = tokens;
+  const cst = parserInstance5.diagram();
+  let direction = "TD";
+  const nodes = /* @__PURE__ */ new Map();
+  const transitions = [];
+  const composites = [];
+  const lanes = [];
+  const stack = [];
+  const diagramChildren = cst.children || {};
+  const stmts = diagramChildren.statement || [];
+  function ensureNode(def) {
+    const ex = nodes.get(def.id);
+    if (ex)
+      return ex;
+    nodes.set(def.id, def);
+    const parentCtx = stack[stack.length - 1];
+    if (parentCtx) {
+      const parent = parentCtx.id;
+      const laneId = `${parent}__lane${parentCtx.lane}`;
+      let laneSg = composites.find((c3) => c3.id === laneId);
+      if (!laneSg) {
+        if (!composites.find((c3) => c3.id === parent))
+          composites.push({ id: parent, label: parent, nodes: [], parent: stack.length > 1 ? stack[stack.length - 2].id : void 0 });
+        composites.push({ id: laneId, label: void 0, nodes: [], parent });
+        lanes.push({ parentId: parent, id: laneId, nodes: [] });
+      }
+      laneSg = composites.find((c3) => c3.id === laneId);
+      if (!laneSg.nodes.includes(def.id))
+        laneSg.nodes.push(def.id);
+      const laneRec = lanes.find((l3) => l3.id === laneId);
+      if (laneRec && !laneRec.nodes.includes(def.id))
+        laneRec.nodes.push(def.id);
+      def.parent = laneId;
+    }
+    return def;
+  }
+  function visitStatement(node) {
+    const ch = node.children || {};
+    if (ch.directionStmt) {
+      const d3 = ch.directionStmt[0].children.Direction?.[0]?.image || "TD";
+      direction = d3;
+      return;
+    }
+    if (ch.stateDecl) {
+      const n3 = ch.stateDecl[0];
+      const dch = n3.children || {};
+      if (dch.QuotedString && dch.AsKw && dch.Identifier) {
+        const label = dch.QuotedString[0].image.slice(1, -1);
+        const id = dch.Identifier[0].image;
+        ensureNode({ id, label, kind: "simple" });
+      } else if (dch.Identifier) {
+        const id = dch.Identifier[0].image;
+        ensureNode({ id, label: id, kind: "simple" });
+      }
+      return;
+    }
+    if (ch.stateBlock) {
+      const b3 = ch.stateBlock[0];
+      const bch = b3.children || {};
+      const idTok = bch.Identifier?.[0] || bch.QuotedString?.[0];
+      const idRaw = idTok ? idTok.image.startsWith('"') ? idTok.image.slice(1, -1) : idTok.image : `__state_${b3.location ?? Math.random()}`;
+      const id = idRaw.replace(/\s+/g, "_");
+      ensureNode({ id, label: idRaw, kind: "composite" });
+      if (!composites.find((c3) => c3.id === id))
+        composites.push({ id, label: idRaw, nodes: [], parent: stack.length ? stack[stack.length - 1].id : void 0 });
+      stack.push({ id, lane: 0 });
+      const inner = bch.innerStatement || [];
+      for (const s3 of inner)
+        visitStatement(s3);
+      stack.pop();
+      return;
+    }
+    if (ch.transitionStmt) {
+      const t3 = ch.transitionStmt[0];
+      const tch = t3.children || {};
+      const left = actorRefToId(tch.actorRef?.[0], { isTarget: false });
+      const right = actorRefToId(tch.actorRef?.[1], { isTarget: true });
+      if (left.id)
+        ensureNode({ id: left.id, label: left.label || left.id, kind: left.kind });
+      if (right.id)
+        ensureNode({ id: right.id, label: right.label || right.id, kind: right.kind });
+      let label;
+      if (tch.Colon && tch.labelText) {
+        const toks = [];
+        tch.labelText.forEach((lt) => {
+          const ch2 = lt.children || {};
+          ["QuotedString", "Identifier", "NumberLiteral", "LabelChunk"].forEach((k3) => ch2[k3]?.forEach((tt) => toks.push(tt)));
+        });
+        toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+        label = textFromTokens2(toks);
+      }
+      if (left.id && right.id)
+        transitions.push({ source: left.id, target: right.id, label });
+      return;
+    }
+    if (node.name === "innerStatement") {
+      const ich = node.children || {};
+      if (ich.Dashes && ich.Dashes.length && stack.length) {
+        stack[stack.length - 1].lane += 1;
+        return;
+      }
+    }
+    if (ch.noteStmt) {
+      const n3 = ch.noteStmt[0];
+      const nch = n3.children || {};
+      const txtToks = [];
+      const targetRef = nch.actorRef?.[0];
+      const target = actorRefToId(targetRef);
+      ["QuotedString", "Identifier", "NumberLiteral", "LabelChunk"].forEach((k3) => nch[k3]?.forEach((tk) => txtToks.push(tk)));
+      const text2 = textFromTokens2(txtToks);
+      if (target.id && text2) {
+        const noteId = `__note_${(n3.location ?? Math.random()).toString().slice(2)}`;
+        ensureNode({ id: noteId, label: text2, kind: "simple" });
+        ensureNode({ id: target.id, label: target.label || target.id, kind: target.kind });
+        transitions.push({ source: noteId, target: target.id, label: void 0 });
+      }
+      return;
+    }
+    if (ch.stateDescriptionStmt) {
+      const s3 = ch.stateDescriptionStmt[0];
+      const sch = s3.children || {};
+      const nameTok = sch.Identifier?.[0] || sch.QuotedString?.[0];
+      if (nameTok) {
+        const raw = nameTok.image.startsWith('"') ? nameTok.image.slice(1, -1) : nameTok.image;
+        const id = raw.replace(/\s+/g, "_");
+        const labelToks = [];
+        ["QuotedString", "Identifier", "NumberLiteral", "LabelChunk"].forEach((k3) => sch[k3]?.forEach((tt) => labelToks.push(tt)));
+        const lbl = textFromTokens2(labelToks);
+        ensureNode({ id, label: lbl || raw, kind: "simple" });
+      }
+      return;
+    }
+    for (const key of Object.keys(ch)) {
+      const arr = ch[key];
+      if (Array.isArray(arr))
+        arr.forEach((n3) => visitStatement(n3));
+    }
+  }
+  for (const st of stmts)
+    visitStatement(st);
+  return {
+    direction,
+    nodes: Array.from(nodes.values()),
+    transitions,
+    composites,
+    lanes
+  };
+}
+var init_state_builder = __esm({
+  "node_modules/@probelabs/maid/out/renderer/state-builder.js"() {
+    init_lexer6();
+    init_parser6();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/state-renderer.js
+function toGraph(model) {
+  const nodes = [];
+  const edges = [];
+  const subgraphs = [];
+  for (const s3 of model.nodes) {
+    let shape = "rectangle";
+    let label = s3.label || s3.id;
+    if (s3.kind === "start") {
+      shape = "circle";
+      label = "";
+    } else if (s3.kind === "end") {
+      shape = "circle";
+      label = "";
+    } else if (s3.kind === "history") {
+      shape = "circle";
+      label = "H";
+    } else if (s3.kind === "history-deep") {
+      shape = "circle";
+      label = "H*";
+    } else if (s3.kind === "choice") {
+      shape = "diamond";
+    } else if (s3.kind === "fork" || s3.kind === "join") {
+      shape = "rectangle";
+    }
+    const node = { id: s3.id, label, shape };
+    if (s3.kind === "fork" || s3.kind === "join") {
+      node.width = 80;
+      node.height = 8;
+    }
+    nodes.push(node);
+  }
+  for (const t3 of model.transitions) {
+    edges.push({ id: `${t3.source}->${t3.target}-${Math.random().toString(36).slice(2, 7)}`, source: t3.source, target: t3.target, label: t3.label, type: "arrow", markerEnd: "arrow" });
+  }
+  for (const c3 of model.composites) {
+    subgraphs.push({ id: c3.id, label: c3.label, nodes: c3.nodes, parent: c3.parent });
+  }
+  const laneGroups = (model.lanes || []).slice();
+  return { graph: { nodes, edges, subgraphs, direction: model.direction }, laneGroups };
+}
+function renderState(model) {
+  var _a16;
+  const { graph, laneGroups } = toGraph(model);
+  const layout = new DagreLayoutEngine().layout(graph);
+  let svg = new SVGRenderer().render(layout);
+  const byId = Object.fromEntries(layout.nodes.map((n3) => [n3.id, { x: n3.x, y: n3.y, width: n3.width, height: n3.height }]));
+  const subById = Object.fromEntries((layout.subgraphs || []).map((s3) => [s3.id, { x: s3.x, y: s3.y, width: s3.width, height: s3.height, label: s3.label }]));
+  const overlays = [];
+  const groupByParent = {};
+  for (const lg of laneGroups) {
+    const parent = subById[lg.parentId];
+    if (!parent)
+      continue;
+    const members = lg.nodes.map((id) => byId[id]).filter(Boolean);
+    if (!members.length)
+      continue;
+    (groupByParent[_a16 = lg.parentId] || (groupByParent[_a16] = [])).push({ id: lg.id, nodes: members });
+  }
+  const laneIndex = (id) => {
+    const m3 = /(.*)__lane(\d+)/.exec(id);
+    return m3 ? parseInt(m3[2], 10) : Number.POSITIVE_INFINITY;
+  };
+  for (const pid of Object.keys(groupByParent)) {
+    const parent = subById[pid];
+    if (!parent)
+      continue;
+    const lanes = groupByParent[pid].slice();
+    if (lanes.every((l3) => /__lane\d+/.test(l3.id)))
+      lanes.sort((a3, b3) => laneIndex(a3.id) - laneIndex(b3.id));
+    else if (graph.direction === "LR" || graph.direction === "RL")
+      lanes.sort((a3, b3) => Math.min(...a3.nodes.map((n3) => n3.x)) - Math.min(...b3.nodes.map((n3) => n3.x)));
+    else
+      lanes.sort((a3, b3) => Math.min(...a3.nodes.map((n3) => n3.y)) - Math.min(...b3.nodes.map((n3) => n3.y)));
+    for (let i3 = 1; i3 < lanes.length; i3++) {
+      const prev = lanes[i3 - 1];
+      const next = lanes[i3];
+      if (graph.direction === "LR" || graph.direction === "RL") {
+        const prevMaxX = Math.max(...prev.nodes.map((n3) => n3.x + n3.width));
+        const nextMinX = Math.min(...next.nodes.map((n3) => n3.x));
+        const x3 = Math.max(parent.x, Math.min(parent.x + parent.width, (prevMaxX + nextMinX) / 2));
+        overlays.push(`<line class="lane-divider" x1="${x3}" y1="${parent.y + 14}" x2="${x3}" y2="${parent.y + parent.height}" />`);
+      } else {
+        const prevMaxY = Math.max(...prev.nodes.map((n3) => n3.y + n3.height));
+        const nextMinY = Math.min(...next.nodes.map((n3) => n3.y));
+        const y2 = Math.max(parent.y + 14, Math.min(parent.y + parent.height, (prevMaxY + nextMinY) / 2));
+        overlays.push(`<line class="lane-divider" x1="${parent.x}" y1="${y2}" x2="${parent.x + parent.width}" y2="${y2}" />`);
+      }
+    }
+  }
+  for (const n3 of layout.nodes) {
+    const src = (model.nodes || []).find((nn) => nn.id === n3.id);
+    if (!src || src.kind !== "end")
+      continue;
+    const cx = n3.x + n3.width / 2;
+    const cy = n3.y + n3.height / 2;
+    const r3 = Math.max(1, Math.min(n3.width, n3.height) / 2 - 3);
+    overlays.push(`<circle class="end-double" cx="${cx}" cy="${cy}" r="${r3}" fill="none" />`);
+  }
+  if (overlays.length) {
+    svg = svg.replace("</svg>", `<g class="state-overlays">${overlays.join("\n")}</g></svg>`);
+  }
+  if (!/<style>/.test(svg)) {
+    const css = buildSharedCss();
+    svg = svg.replace("<svg ", `<svg `).replace("</svg>", `<style>${css}</style></svg>`);
+  }
+  return svg;
+}
+var init_state_renderer = __esm({
+  "node_modules/@probelabs/maid/out/renderer/state-renderer.js"() {
+    init_layout();
+    init_svg_generator();
+    init_styles();
+  }
+});
+
 // node_modules/@probelabs/maid/out/core/frontmatter.js
 function parseFrontmatter(input) {
   const text = input.startsWith("\uFEFF") ? input.slice(1) : input;
@@ -57853,6 +59613,443 @@ var init_frontmatter = __esm({
   }
 });
 
+// node_modules/@probelabs/maid/out/renderer/class-builder.js
+function textFromTokens3(tokens) {
+  if (!tokens || tokens.length === 0)
+    return "";
+  const parts = [];
+  for (const t3 of tokens) {
+    const img = t3.image ?? "";
+    if (t3.tokenType && t3.tokenType.name === "QuotedString") {
+      if (img.startsWith('"') && img.endsWith('"'))
+        parts.push(img.slice(1, -1));
+      else if (img.startsWith("'") && img.endsWith("'"))
+        parts.push(img.slice(1, -1));
+      else
+        parts.push(img);
+    } else {
+      parts.push(img);
+    }
+  }
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+function classRefToText(refCst) {
+  if (!refCst)
+    return "";
+  const ch = refCst.children || {};
+  const toks = [];
+  ["Identifier", "QuotedString", "BacktickName"].forEach((k3) => {
+    const arr = ch[k3];
+    arr?.forEach((t3) => toks.push(t3));
+  });
+  toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+  return textFromTokens3(toks);
+}
+function memberLineToText(member) {
+  const ch = member.children || {};
+  const toks = [];
+  const order = ["Visibility", "Identifier", "QuotedString", "LParen", "RParen", "Comma", "Colon", "NumberLiteral"];
+  for (const k3 of order)
+    ch[k3]?.forEach((t3) => toks.push(t3));
+  toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+  const txt = textFromTokens3(toks);
+  const isMethod = /(\)\s*:|\)$)/.test(txt) || /\(/.test(txt);
+  return { text: txt, isMethod };
+}
+function canonicalId2(raw) {
+  return raw.trim().replace(/\s+/g, "_");
+}
+function buildClassModel(text) {
+  const { tokens } = tokenize4(text);
+  parserInstance4.input = tokens;
+  const cst = parserInstance4.diagram();
+  const classes = /* @__PURE__ */ new Map();
+  const relations = [];
+  const notes = [];
+  let direction = "TD";
+  function ensureClass(idRaw, display) {
+    const id = canonicalId2(idRaw);
+    const existing = classes.get(id);
+    if (existing)
+      return existing;
+    const def = { id, display: display || idRaw, attributes: [], methods: [] };
+    classes.set(id, def);
+    return def;
+  }
+  const diagramChildren = cst.children || {};
+  const stmts = diagramChildren.statement || [];
+  for (const st of stmts) {
+    const ch = st.children || {};
+    if (ch.directionStmt) {
+      const d3 = ch.directionStmt[0].children.Direction?.[0]?.image || "TD";
+      if (d3 === "TB")
+        direction = "TB";
+      else if (d3 === "BT")
+        direction = "BT";
+      else if (d3 === "LR")
+        direction = "LR";
+      else if (d3 === "RL")
+        direction = "RL";
+      else
+        direction = "TD";
+      continue;
+    }
+    if (ch.classLine) {
+      const node = ch.classLine[0];
+      const nch = node.children || {};
+      const name14 = classRefToText(nch.classRef?.[0]);
+      const def = ensureClass(name14);
+      if (nch.LTlt && nch.Identifier && nch.GTgt) {
+        def.stereotype = nch.Identifier[0].image;
+      }
+      if (nch.LCurly && nch.memberLineStmt) {
+        const lines = nch.memberLineStmt;
+        for (const m3 of lines) {
+          const mm = memberLineToText(m3.children.memberLine?.[0]);
+          if (!mm.text)
+            continue;
+          (mm.isMethod ? def.methods : def.attributes).push(mm.text);
+        }
+      }
+      continue;
+    }
+    if (ch.memberAssignStmt) {
+      const node = ch.memberAssignStmt[0];
+      const nch = node.children || {};
+      const clsName = classRefToText(nch.classRef?.[0]);
+      const def = ensureClass(clsName);
+      const mm = memberLineToText(nch.memberLine?.[0]);
+      if (mm.text)
+        (mm.isMethod ? def.methods : def.attributes).push(mm.text);
+      continue;
+    }
+    if (ch.noteStmt) {
+      const node = ch.noteStmt[0];
+      const nch = node.children || {};
+      const target = classRefToText(nch.classRef?.[0]);
+      const labelToks = [];
+      ["QuotedString", "Identifier", "NumberLiteral"].forEach((k3) => nch[k3]?.forEach((t3) => labelToks.push(t3)));
+      const text2 = textFromTokens3(labelToks);
+      if (target && text2)
+        notes.push({ target: canonicalId2(target), text: text2 });
+      continue;
+    }
+    if (ch.relationStmt) {
+      const node = ch.relationStmt[0];
+      const rch = node.children || {};
+      const leftName = classRefToText(rch.classRef?.[0]);
+      const rightName = classRefToText(rch.classRef?.[1]);
+      const left = ensureClass(leftName).id;
+      const right = ensureClass(rightName).id;
+      const leftCardTok = rch.leftCard?.[0];
+      const rightCardTok = rch.rightCard?.[0];
+      const leftCard = leftCardTok?.image ? leftCardTok.image.slice(1, -1) : void 0;
+      const rightCard = rightCardTok?.image ? rightCardTok.image.slice(1, -1) : void 0;
+      let label;
+      if (rch.labelText) {
+        const toks = [];
+        rch.labelText.forEach((lt) => {
+          const ch2 = lt.children || {};
+          ["QuotedString", "Identifier", "NumberLiteral", "GenericAngle"].forEach((k3) => {
+            ch2[k3]?.forEach((t3) => toks.push(t3));
+          });
+        });
+        toks.sort((a3, b3) => (a3.startOffset ?? 0) - (b3.startOffset ?? 0));
+        label = textFromTokens3(toks);
+      }
+      const relMap = [
+        { key: "RelAssociation", kind: "association" },
+        { key: "RelDependency", kind: "dependency" },
+        { key: "RelRealization", kind: "realization" },
+        { key: "RelExtends", kind: "extends" },
+        { key: "RelAggregation", kind: "aggregation" },
+        { key: "RelComposition", kind: "composition" },
+        { key: "RelDependencyLeft", kind: "dependency" },
+        { key: "RelRealizationLeft", kind: "realization" },
+        { key: "RelExtendsRight", kind: "extends" },
+        { key: "RelAggBoth", kind: "aggregation-both" },
+        { key: "RelCompBoth", kind: "composition-both" },
+        { key: "RelAggToComp", kind: "aggregation-to-comp" },
+        { key: "RelCompToAgg", kind: "composition-to-agg" },
+        { key: "LollipopLeft", kind: "lollipop-left" },
+        { key: "LollipopRight", kind: "lollipop-right" }
+      ];
+      let kind = "association";
+      for (const m3 of relMap) {
+        if (rch[m3.key]) {
+          kind = m3.kind;
+          break;
+        }
+      }
+      let src = left, dst = right;
+      if (rch.RelExtends || rch.RelDependencyLeft || rch.RelRealizationLeft || rch.LollipopLeft) {
+        src = right;
+        dst = left;
+      }
+      const rel = { source: src, target: dst, kind, label, leftCard, rightCard };
+      relations.push(rel);
+      continue;
+    }
+  }
+  return {
+    direction,
+    classes: Array.from(classes.values()),
+    relations,
+    notes
+  };
+}
+var init_class_builder = __esm({
+  "node_modules/@probelabs/maid/out/renderer/class-builder.js"() {
+    init_lexer5();
+    init_parser5();
+  }
+});
+
+// node_modules/@probelabs/maid/out/renderer/class-renderer.js
+function classNodeSize(def, fontSize = 14) {
+  const title = def.stereotype ? `\xAB${def.stereotype}\xBB ${def.display}` : def.display;
+  const attrLines = def.attributes.slice();
+  const methodLines = def.methods.slice();
+  const lineH = Math.max(16, Math.round(fontSize * 1.1));
+  const padX = 12, padY = 10;
+  const titleW = measureText(title, fontSize + 1) + padX * 2;
+  const attrsW = Math.max(0, ...attrLines.map((t3) => measureText(t3, fontSize))) + padX * 2;
+  const methodsW = Math.max(0, ...methodLines.map((t3) => measureText(t3, fontSize))) + padX * 2;
+  const width = Math.max(120, titleW, attrsW, methodsW);
+  const sepH = (attrLines.length ? 6 : 0) + (methodLines.length ? 6 : 0);
+  const height = padY * 2 + lineH + attrLines.length * lineH + (methodLines.length ? 6 : 0) + (attrLines.length ? 6 : 0) + methodLines.length * lineH;
+  return { width, height, title, attrLines, methodLines };
+}
+function triangleOpenAt(points, color, length = 10, width = 8, atEnd = true) {
+  const [a3, b3] = atEnd ? points : [points[1], points[0]];
+  const vx = b3.x - a3.x, vy = b3.y - a3.y;
+  const len = Math.hypot(vx, vy) || 1;
+  const ux = vx / len, uy = vy / len;
+  const nx = -uy, ny = ux;
+  const tip = { x: b3.x, y: b3.y };
+  const base = { x: b3.x - ux * length, y: b3.y - uy * length };
+  const p22 = { x: base.x + nx * (width / 2), y: base.y + ny * (width / 2) };
+  const p3 = { x: base.x - nx * (width / 2), y: base.y - ny * (width / 2) };
+  return `<path class="edge-marker" d="M${tip.x},${tip.y} L${p22.x},${p22.y} M${tip.x},${tip.y} L${p3.x},${p3.y}" stroke="${color}" fill="none" />`;
+}
+function triangleHollowAt(points, color, length = 12, width = 10, atEnd = true) {
+  const [a3, b3] = atEnd ? points : [points[1], points[0]];
+  const vx = b3.x - a3.x, vy = b3.y - a3.y;
+  const len = Math.hypot(vx, vy) || 1;
+  const ux = vx / len, uy = vy / len;
+  const nx = -uy, ny = ux;
+  const tip = { x: b3.x, y: b3.y };
+  const base = { x: b3.x - ux * length, y: b3.y - uy * length };
+  const p22 = { x: base.x + nx * (width / 2), y: base.y + ny * (width / 2) };
+  const p3 = { x: base.x - nx * (width / 2), y: base.y - ny * (width / 2) };
+  const d3 = `M${tip.x},${tip.y} L${p22.x},${p22.y} L${p3.x},${p3.y} Z`;
+  return `<path class="edge-marker" d="${d3}" fill="white" stroke="${color}" />`;
+}
+function diamondAt(points, color, filled, size = 10, atStart = true) {
+  const [a3, b3] = atStart ? points : [points[1], points[0]];
+  const vx = b3.x - a3.x, vy = b3.y - a3.y;
+  const len = Math.hypot(vx, vy) || 1;
+  const ux = vx / len, uy = vy / len;
+  const nx = -uy, ny = ux;
+  const center = { x: a3.x, y: a3.y };
+  const pTip = { x: center.x - ux * size, y: center.y - uy * size };
+  const pLeft = { x: center.x + nx * (size / 1.4), y: center.y + ny * (size / 1.4) };
+  const pRight = { x: center.x - nx * (size / 1.4), y: center.y - ny * (size / 1.4) };
+  const pBack = { x: center.x + ux * size, y: center.y + uy * size };
+  const d3 = `M${pTip.x},${pTip.y} L${pLeft.x},${pLeft.y} L${pBack.x},${pBack.y} L${pRight.x},${pRight.y} Z`;
+  return filled ? `<path class="edge-marker edge-marker-fill" d="${d3}" fill="${color}" stroke="${color}"/>` : `<path class="edge-marker" d="${d3}" fill="white" stroke="${color}"/>`;
+}
+function polyline(points, cls, dashed = false, stroke = "#555", strokeWidth = 2) {
+  const d3 = points.map((p3) => `${p3.x},${p3.y}`).join(" ");
+  const dash = dashed ? ` stroke-dasharray="4 3"` : "";
+  return `<polyline class="edge-path ${cls}" points="${d3}" fill="none"${dash}/>`;
+}
+function renderClass(model, opts = {}) {
+  const nodes = [];
+  const nodeSizeInfo = {};
+  for (const c3 of model.classes) {
+    const sz = classNodeSize(c3);
+    nodeSizeInfo[c3.id] = sz;
+    nodes.push({ id: c3.id, label: c3.display, shape: "rectangle", width: sz.width, height: sz.height });
+  }
+  const edges = model.relations.map((r3, i3) => ({ id: `e${i3}`, source: r3.source, target: r3.target, type: "open" }));
+  const graph = { nodes, edges, direction: model.direction };
+  const layoutEngine = new DagreLayoutEngine();
+  const layout = layoutEngine.layout(graph);
+  const width = Math.ceil(layout.width + 40);
+  const height = Math.ceil(layout.height + 40);
+  const parts = [];
+  parts.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${Math.min(0, -20)} ${Math.min(0, -20)} ${width} ${height}">`);
+  const sharedCss = buildSharedCss();
+  parts.push(`<style>${sharedCss}
+    .class-title { font-weight: 600; }
+    .class-divider { stroke: #aaa; stroke-width: 1; }
+    .class-member { font-size: 12px; }
+  </style>`);
+  for (const n3 of layout.nodes) {
+    const info = nodeSizeInfo[n3.id];
+    const x3 = n3.x, y2 = n3.y, w3 = n3.width, h3 = n3.height;
+    const title = info.title;
+    const attrs = info.attrLines;
+    const methods = info.methodLines;
+    const lineH = 16;
+    const padX = 12;
+    const padY = 10;
+    let cy = y2 + padY + lineH;
+    parts.push(`  <g transform="translate(${x3},${y2})">`);
+    parts.push(`    <rect class="node-shape" width="${w3}" height="${h3}" rx="0"/>`);
+    parts.push(`    <text class="node-label class-title" x="${w3 / 2}" y="${padY + 12}" text-anchor="middle" dominant-baseline="middle">${escapeXml(title)}</text>`);
+    let yCursor = padY + 18;
+    if (attrs.length) {
+      parts.push(`    <line class="class-divider" x1="0" y1="${yCursor}" x2="${w3}" y2="${yCursor}"/>`);
+      yCursor += 8;
+      for (const a3 of attrs) {
+        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml(a3)}</text>`);
+        yCursor += lineH;
+      }
+    }
+    if (methods.length) {
+      parts.push(`    <line class="class-divider" x1="0" y1="${yCursor}" x2="${w3}" y2="${yCursor}"/>`);
+      yCursor += 8;
+      for (const m3 of methods) {
+        parts.push(`    <text class="node-label class-member" x="${padX}" y="${yCursor}" dominant-baseline="hanging">${escapeXml(m3)}</text>`);
+        yCursor += lineH;
+      }
+    }
+    parts.push("  </g>");
+  }
+  const edgeColor = "#555";
+  for (let i3 = 0; i3 < layout.edges.length; i3++) {
+    const e3 = layout.edges[i3];
+    const rel = model.relations[i3];
+    const pts = e3.points;
+    const dashed = rel.kind === "dependency" || rel.kind === "realization";
+    parts.push(polyline(pts, "edge-path", dashed, edgeColor, 2));
+    const placeEndpoint = (pt, next, text, side) => {
+      const vx = next.x - pt.x;
+      const vy = next.y - pt.y;
+      const vlen = Math.hypot(vx, vy) || 1;
+      const ux = vx / vlen;
+      const uy = vy / vlen;
+      const nx = -uy;
+      const ny = ux;
+      const away = -6;
+      const perp = 8;
+      const x3 = pt.x + ux * away + nx * perp;
+      const y2 = pt.y + uy * away + ny * perp;
+      const anchor = side === "start" ? "end" : "start";
+      parts.push(`<text class="edge-label-text" x="${x3}" y="${y2}" text-anchor="${anchor}">${escapeXml(text)}</text>`);
+    };
+    if (rel.leftCard && pts.length >= 2)
+      placeEndpoint(pts[0], pts[1], rel.leftCard, "start");
+    if (rel.rightCard && pts.length >= 2) {
+      const a3 = pts[pts.length - 1];
+      const b3 = pts[pts.length - 2];
+      placeEndpoint(a3, b3, rel.rightCard, "end");
+    }
+    if (rel.label) {
+      const mid = pts[Math.floor(pts.length / 2)];
+      const words = String(rel.label).split(/\s+/);
+      const lines = [];
+      let cur = "";
+      const maxW = 200;
+      for (const w3 of words) {
+        const test = cur ? cur + " " + w3 : w3;
+        if (measureText(test, 12) <= maxW)
+          cur = test;
+        else {
+          if (cur)
+            lines.push(cur);
+          cur = w3;
+        }
+      }
+      if (cur)
+        lines.push(cur);
+      const dy = 14;
+      let y0 = mid.y - (lines.length - 1) * dy / 2 - 10;
+      parts.push(`<text class="edge-label-text" x="${mid.x}" y="${y0}" text-anchor="middle">` + lines.map((ln, i4) => `<tspan x="${mid.x}" dy="${i4 === 0 ? 0 : dy}">${escapeXml(ln)}</tspan>`).join("") + `</text>`);
+    }
+    const pStart = [pts[0], pts[1] ?? pts[0]];
+    const pEnd = [pts[pts.length - 2] ?? pts[pts.length - 1], pts[pts.length - 1]];
+    switch (rel.kind) {
+      case "extends":
+        parts.push(triangleHollowAt(pEnd, edgeColor, 12, 10, true));
+        break;
+      case "realization":
+        parts.push(triangleHollowAt(pEnd, edgeColor, 12, 10, true));
+        break;
+      case "dependency":
+        parts.push(triangleOpenAt(pEnd, edgeColor, 10, 7, true));
+        break;
+      case "aggregation":
+        parts.push(diamondAt(pStart, edgeColor, false, 8, true));
+        break;
+      case "composition":
+        parts.push(diamondAt(pStart, edgeColor, true, 8, true));
+        break;
+      case "aggregation-both":
+        parts.push(diamondAt(pStart, edgeColor, false, 8, true));
+        parts.push(diamondAt(pEnd, edgeColor, false, 8, false));
+        break;
+      case "composition-both":
+        parts.push(diamondAt(pStart, edgeColor, true, 8, true));
+        parts.push(diamondAt(pEnd, edgeColor, true, 8, false));
+        break;
+      case "aggregation-to-comp":
+        parts.push(diamondAt(pStart, edgeColor, false, 8, true));
+        parts.push(diamondAt(pEnd, edgeColor, true, 8, false));
+        break;
+      case "composition-to-agg":
+        parts.push(diamondAt(pStart, edgeColor, true, 8, true));
+        parts.push(diamondAt(pEnd, edgeColor, false, 8, false));
+        break;
+      case "lollipop-left":
+        parts.push(`<circle class="edge-marker" cx="${pStart[0].x}" cy="${pStart[0].y}" r="5" fill="white" stroke="${edgeColor}" />`);
+        break;
+      case "lollipop-right":
+        parts.push(`<circle class="edge-marker" cx="${pEnd[1].x}" cy="${pEnd[1].y}" r="5" fill="white" stroke="${edgeColor}" />`);
+        break;
+      case "association":
+      default:
+        break;
+    }
+  }
+  const noteW = 140, noteH = 44, dx = 20;
+  const byId = Object.fromEntries(layout.nodes.map((n3) => [n3.id, n3]));
+  const seenAnchorCount = {};
+  const notes = model.notes || [];
+  for (const note of notes) {
+    const anchor = byId[note.target];
+    if (!anchor)
+      continue;
+    const count = seenAnchorCount[note.target] = (seenAnchorCount[note.target] || 0) + 1;
+    const nx = anchor.x + anchor.width + dx;
+    let ny = anchor.y + (count - 1) * (noteH + 8);
+    const overlaps = (x3, y2) => layout.nodes.some((n3) => !(x3 + noteW < n3.x || x3 > n3.x + n3.width || y2 + noteH < n3.y || y2 > n3.y + n3.height));
+    let guard = 0;
+    while (overlaps(nx, ny) && guard < 50) {
+      ny += noteH + 6;
+      guard++;
+    }
+    parts.push(`  <g class="note" transform="translate(${nx},${ny})">`);
+    parts.push(`    <rect width="${noteW}" height="${noteH}" rx="0"/>`);
+    parts.push(`    <text class="note-text" x="${noteW / 2}" y="${noteH / 2 + 4}" text-anchor="middle">${escapeXml(note.text)}</text>`);
+    parts.push("  </g>");
+    const ax = anchor.x + anchor.width;
+    const ay = anchor.y + 16;
+    parts.push(`<line x1="${ax}" y1="${ay}" x2="${nx}" y2="${ny + noteH / 2}" stroke="#999" stroke-dasharray="4 3"/>`);
+  }
+  parts.push("</svg>");
+  return parts.join("\n");
+}
+var init_class_renderer = __esm({
+  "node_modules/@probelabs/maid/out/renderer/class-renderer.js"() {
+    init_layout();
+    init_styles();
+    init_utils4();
+  }
+});
+
 // node_modules/@probelabs/maid/out/renderer/dot-renderer.js
 var init_dot_renderer = __esm({
   "node_modules/@probelabs/maid/out/renderer/dot-renderer.js"() {
@@ -57936,6 +60133,10 @@ function applyFlowchartTheme(svg, theme) {
     out = out.replace(/(<path d="M0,0 L0,[0-9.]+ L[0-9.]+,[0-9.]+ z"[^>]*)(fill="[^"]*")/g, (_m2, p1) => `${p1}fill="${String(theme.arrowheadColor)}"`);
     out = out.replace(/(<circle cx="4\.5" cy="4\.5" r="4\.5"[^>]*)(fill="[^"]*")/g, (_m2, p1) => `${p1}fill="${String(theme.arrowheadColor)}"`);
   }
+  if (theme.edgeLabelTextColor) {
+    const c3 = String(theme.edgeLabelTextColor);
+    out = out.replace(/\.edge-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${c3};`));
+  }
   if (theme.clusterBkg) {
     out = out.replace(/\.cluster-bg\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterBkg)};`));
   }
@@ -57945,6 +60146,12 @@ function applyFlowchartTheme(svg, theme) {
   if (theme.clusterTextColor) {
     out = out.replace(/\.cluster-label-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.clusterTextColor)};`));
   }
+  if (theme.noteBkg)
+    out = out.replace(/\.note\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.noteBkg)};`));
+  if (theme.noteBorder)
+    out = out.replace(/\.note\s*\{[^}]*\}/, (m3) => m3.replace(/stroke:\s*[^;]+;/, `stroke: ${String(theme.noteBorder)};`));
+  if (theme.noteTextColor)
+    out = out.replace(/\.note-text\s*\{[^}]*\}/, (m3) => m3.replace(/fill:\s*[^;]+;/, `fill: ${String(theme.noteTextColor)};`));
   if (theme.fontFamily)
     out = out.replace(/\.node-label\s*\{[^}]*\}/, (m3) => m3.replace(/font-family:\s*[^;]+;/, `font-family: ${String(theme.fontFamily)};`));
   if (theme.fontSize)
@@ -57967,7 +60174,12 @@ var init_renderer = __esm({
     init_pie_renderer();
     init_sequence_builder();
     init_sequence_renderer();
+    init_styles();
+    init_state_builder();
+    init_state_renderer();
     init_frontmatter();
+    init_class_builder();
+    init_class_renderer();
     init_layout();
     init_svg_generator();
     init_dot_renderer();
@@ -58102,7 +60314,31 @@ var init_renderer = __esm({
             return { svg: this.generateErrorSvg(msg), graph: { nodes: [], edges: [], direction: "TD" }, errors: err };
           }
         }
-        const errorSvg = this.generateErrorSvg("Unsupported diagram type. Rendering supports flowchart, pie, and sequence for now.");
+        if (/^classDiagram\b/.test(firstLine)) {
+          try {
+            const model = buildClassModel(content);
+            const svg = renderClass(model, { theme });
+            const themed = theme ? applyFlowLikeTheme(svg, theme) : svg;
+            return { svg: themed, graph: { nodes: [], edges: [], direction: model.direction }, errors: [] };
+          } catch (e3) {
+            const msg = e3?.message || "Class render error";
+            const err = [{ line: 1, column: 1, message: msg, severity: "error", code: "CLASS_RENDER" }];
+            return { svg: this.generateErrorSvg(msg), graph: { nodes: [], edges: [], direction: "TD" }, errors: err };
+          }
+        }
+        if (/^stateDiagram(?:-v2)?\b/.test(firstLine)) {
+          try {
+            const model = buildStateModel(content);
+            const svg = renderState(model);
+            const themed = theme ? applyFlowLikeTheme(svg, theme) : svg;
+            return { svg: themed, graph: { nodes: [], edges: [], direction: model.direction }, errors: [] };
+          } catch (e3) {
+            const msg = e3?.message || "State render error";
+            const err = [{ line: 1, column: 1, message: msg, severity: "error", code: "STATE_RENDER" }];
+            return { svg: this.generateErrorSvg(msg), graph: { nodes: [], edges: [], direction: "TD" }, errors: err };
+          }
+        }
+        const errorSvg = this.generateErrorSvg("Unsupported diagram type. Rendering supports flowchart, pie, sequence, class, and state.");
         return {
           svg: errorSvg,
           graph: { nodes: [], edges: [], direction: "TD" },
@@ -58496,13 +60732,14 @@ async function validateMermaidDiagram(diagram) {
       };
     }
     const result = validate(diagram);
-    if (result.errors && result.errors.length === 0) {
+    const actualErrors = (result.errors || []).filter((err) => err.severity === "error");
+    if (actualErrors.length === 0) {
       return {
         isValid: true,
         diagramType: result.type || "unknown"
       };
     } else {
-      const errorMessages = (result.errors || []).map((err) => {
+      const errorMessages = actualErrors.map((err) => {
         const location = err.line ? `line ${err.line}${err.column ? `:${err.column}` : ""}` : "";
         return location ? `${location} - ${err.message}` : err.message;
       });
@@ -58511,8 +60748,8 @@ async function validateMermaidDiagram(diagram) {
         diagramType: result.type || "unknown",
         error: errorMessages[0] || "Validation failed",
         detailedError: errorMessages.join("\n"),
-        errors: result.errors || []
-        // Include raw maid errors for AI fixing
+        errors: actualErrors
+        // Include only actual errors for AI fixing
       };
     }
   } catch (error2) {
@@ -59400,10 +61637,19 @@ var init_client2 = __esm({
           if (this.debug) {
             console.error(`[MCP] Calling ${toolName} with args:`, args);
           }
-          const result = await clientInfo.client.callTool({
-            name: tool3.originalName,
-            arguments: args
+          const timeout = this.config?.settings?.timeout || 3e4;
+          const timeoutPromise = new Promise((_2, reject2) => {
+            setTimeout(() => {
+              reject2(new Error(`MCP tool call timeout after ${timeout}ms`));
+            }, timeout);
           });
+          const result = await Promise.race([
+            clientInfo.client.callTool({
+              name: tool3.originalName,
+              arguments: args
+            }),
+            timeoutPromise
+          ]);
           return result;
         } catch (error2) {
           console.error(`[MCP] Error calling tool ${toolName}:`, error2);
@@ -59817,11 +62063,39 @@ var init_ProbeAgent = __esm({
         this.mcpServers = options.mcpServers || null;
         this.mcpBridge = null;
         this.initializeModel();
+      }
+      /**
+       * Initialize the agent asynchronously (must be called after constructor)
+       * This method initializes MCP and merges MCP tools into the tool list
+       */
+      async initialize() {
         if (this.enableMcp) {
-          this.initializeMCP().catch((error2) => {
+          try {
+            await this.initializeMCP();
+            if (this.mcpBridge) {
+              const mcpTools = this.mcpBridge.mcpTools || {};
+              for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
+                this.toolImplementations[toolName] = toolImpl;
+              }
+            }
+            if (this.debug) {
+              const allToolNames = Object.keys(this.toolImplementations);
+              const nativeToolCount = allToolNames.filter((name14) => !this.mcpBridge?.mcpTools?.[name14]).length;
+              const mcpToolCount = allToolNames.length - nativeToolCount;
+              console.error("\n[DEBUG] ========================================");
+              console.error("[DEBUG] All Tools Initialized");
+              console.error(`[DEBUG] Native tools: ${nativeToolCount}, MCP tools: ${mcpToolCount}`);
+              console.error("[DEBUG] Available tools:");
+              for (const toolName of allToolNames) {
+                const isMCP = this.mcpBridge?.mcpTools?.[toolName] ? " (MCP)" : "";
+                console.error(`[DEBUG]   - ${toolName}${isMCP}`);
+              }
+              console.error("[DEBUG] ========================================\n");
+            }
+          } catch (error2) {
             console.error("[MCP] Failed to initialize MCP:", error2);
             this.mcpBridge = null;
-          });
+          }
         }
       }
       /**
@@ -60048,20 +62322,40 @@ var init_ProbeAgent = __esm({
         }
       }
       /**
-       * Extract directory paths from listFiles tool output
+       * Extract directory paths from tool output (both listFiles and extract tool)
        * @param {string} content - Tool output content
        * @returns {string[]} - Array of directory paths
        */
       extractListFilesDirectories(content) {
         const directories = [];
-        const dirPattern = /^([^\n:]+):\s*$/gm;
+        const fileHeaderPattern = /^File:\s+(.+)$/gm;
         let match;
+        while ((match = fileHeaderPattern.exec(content)) !== null) {
+          const filePath = match[1].trim();
+          const dir = (0, import_path9.dirname)(filePath);
+          if (dir && dir !== ".") {
+            directories.push(dir);
+            if (this.debug) {
+              console.log(`[DEBUG] Extracted directory context from File header: ${dir}`);
+            }
+          }
+        }
+        const dirPattern = /^(\/[^\n:]+|[A-Z]:\\[^\n:]+|\.\.?(?:\/[^\n:]+)?):\s*$/gm;
         while ((match = dirPattern.exec(content)) !== null) {
           const dirPath = match[1].trim();
-          if (dirPath && dirPath.length > 0) {
-            directories.push(dirPath);
-            if (this.debug) {
-              console.log(`[DEBUG] Extracted directory context from listFiles: ${dirPath}`);
+          const hasInvalidChars = /\s/.test(dirPath);
+          const isValidPath = !hasInvalidChars && (dirPath.startsWith("/") || // Unix absolute path
+          /^[A-Z]:\\/.test(dirPath) || // Windows absolute path (C:\)
+          dirPath === "." || // Current directory
+          dirPath === ".." || // Parent directory
+          dirPath.startsWith("./") && dirPath.length > 2 && !dirPath.includes(" ") || // ./something (no spaces)
+          dirPath.startsWith("../") && dirPath.length > 3 && !dirPath.includes(" "));
+          if (isValidPath) {
+            if (!directories.includes(dirPath)) {
+              directories.push(dirPath);
+              if (this.debug) {
+                console.log(`[DEBUG] Extracted directory context from listFiles: ${dirPath}`);
+              }
             }
           }
         }