schematex 0.5.0 → 0.5.2

package/dist/{chunk-GTDQAN2Z.js → chunk-OK5ZS3LU.js}

@@ -1,5 +1,5 @@
 import { orgchart } from './chunk-I55HO32M.js';
-import { circuit } from './chunk-HUPDIRBX.js';
+import { circuit } from './chunk-VCH7RI5H.js';
 import { blockdiagram } from './chunk-EPKIJEH7.js';
 import { ladder } from './chunk-IBRW3UOA.js';
 import { sld } from './chunk-6OSUNBZY.js';
@@ -16,7 +16,7 @@ import { sociogram } from './chunk-ZX74KJPM.js';
 import { timing } from './chunk-6URNSB6G.js';
 import { logic } from './chunk-ZYRCPSBU.js';
 import { resolveBaseTheme, resolveTimelineTheme, cssCustomProperties, resolveMindmapTheme } from './chunk-2VNMKOUO.js';
-import { matchQuotedTitle } from './chunk-5IKOLUWK.js';
+import { matchQuotedTitle, stripQuotes } from './chunk-5IKOLUWK.js';
 import { el, escapeXml, title, desc, text, path, rect, group, svgRoot, defs, circle, polygon, line, multilineText } from './chunk-SYYBKDL7.js';
 
 // src/diagrams/decisiontree/parser.ts
@@ -3935,7 +3935,7 @@ function renderLayout(layout) {
 var state = {
   type: "state",
   detect(text2) {
-    return /^\s*state\b/i.test(text2);
+    return /^\s*(?:state\b|stateDiagram(?:-v2)?\b)/i.test(text2);
   },
   parse: parseStateDiagram,
   render(text2, config) {
@@ -7184,7 +7184,7 @@ function parseHeader(state2) {
     if (!m) break;
     const key = m[1].toLowerCase();
     const valueRaw = m[2].trim();
-    const value = stripQuotes(valueRaw);
+    const value = stripQuotes2(valueRaw);
     if (key === "title") state2.ast.title = value;
     else if (key === "system") state2.ast.system = value;
     else if (key === "direction") {
@@ -7202,7 +7202,7 @@ function parseHeader(state2) {
     state2.i++;
   }
 }
-function stripQuotes(s) {
+function stripQuotes2(s) {
   const t = s.trim();
   if (t.startsWith('"') && t.endsWith('"') && t.length >= 2) return t.slice(1, -1);
   return t;
@@ -7239,7 +7239,7 @@ function parseActorDecl(ln, state2) {
     id = asMatch[1];
     rest = rest.slice(0, asMatch.index).trim();
   }
-  const name = stripQuotes(rest);
+  const name = stripQuotes2(rest);
   if (!name) throw new UsecaseParseError(`actor declaration missing name`, ln.line);
   const actorId = id ?? defaultIdFor(name);
   declareId(state2, actorId, "actor", ln.line);
@@ -7275,7 +7275,7 @@ function parseUsecaseDecl(ln, state2) {
     id = asMatch[1];
     rest = rest.slice(0, asMatch.index).trim();
   }
-  const name = stripQuotes(rest);
+  const name = stripQuotes2(rest);
   if (!name) throw new UsecaseParseError(`usecase declaration missing name`, ln.line);
   const ucId = id ?? defaultIdFor(name);
   declareId(state2, ucId, "usecase", ln.line);
@@ -8030,13 +8030,13 @@ function layoutUsecase(ast) {
       pb = perimeter(r.target, a.cx, a.cy);
     }
     const dashed = r.kind === "include" || r.kind === "extend";
-    let arrowKind = "none";
-    if (r.kind === "directed" || r.kind === "include" || r.kind === "extend") arrowKind = "open";
-    else if (r.kind === "generalization") arrowKind = "hollow";
+    let arrowKind2 = "none";
+    if (r.kind === "directed" || r.kind === "include" || r.kind === "extend") arrowKind2 = "open";
+    else if (r.kind === "generalization") arrowKind2 = "hollow";
     const edge = {
       relation: r,
       d: `M ${round(pa.x)} ${round(pa.y)} L ${round(pb.x)} ${round(pb.y)}`,
-      arrowKind,
+      arrowKind: arrowKind2,
       dashed
     };
     if (r.kind === "include" || r.kind === "extend") {
@@ -8519,7 +8519,7 @@ function preprocess7(src) {
   }
   return out;
 }
-function stripQuotes2(s) {
+function stripQuotes3(s) {
   const t = s.trim();
   if (t.length >= 2 && (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'"))) {
     return t.slice(1, -1);
@@ -8537,7 +8537,7 @@ function parseHeaderLine(ln, ast) {
   if (!m) return false;
   const key = m[1].toLowerCase();
   const valueRaw = m[2].trim();
-  const value = stripQuotes2(valueRaw);
+  const value = stripQuotes3(valueRaw);
   switch (key) {
     case "title":
       ast.title = value;
@@ -8666,23 +8666,23 @@ function parseTaskLine(ln, ast) {
     milestone = true;
     return "";
   }).trim();
-  const markers3 = [];
+  const markers4 = [];
   KEY_RE.lastIndex = 0;
   let mm;
   while ((mm = KEY_RE.exec(rest)) !== null) {
-    markers3.push({ key: mm[1].toLowerCase(), start: mm.index, valStart: mm.index + mm[0].length });
+    markers4.push({ key: mm[1].toLowerCase(), start: mm.index, valStart: mm.index + mm[0].length });
   }
   const values = {};
-  for (let i = 0; i < markers3.length; i++) {
-    const cur = markers3[i];
-    const nextStart = i + 1 < markers3.length ? markers3[i + 1].start : rest.length;
+  for (let i = 0; i < markers4.length; i++) {
+    const cur = markers4[i];
+    const nextStart = i + 1 < markers4.length ? markers4[i + 1].start : rest.length;
     const val = rest.slice(cur.valStart, nextStart).trim();
     if (cur.key in values) {
       throw new PertParseError(`duplicate '${cur.key}:' on task '${id}'`, ln.line);
     }
     values[cur.key] = val;
   }
-  const preamble = (markers3.length ? rest.slice(0, markers3[0].start) : rest).trim();
+  const preamble = (markers4.length ? rest.slice(0, markers4[0].start) : rest).trim();
   if (preamble) {
     throw new PertParseError(`unexpected text '${preamble}' in task '${id}'`, ln.line);
   }
@@ -8710,7 +8710,7 @@ function parseTaskLine(ln, ast) {
   }
   const tags = values.tags ? values.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
   const className = values.class ? values.class.trim() : void 0;
-  const lane = values.lane ? stripQuotes2(values.lane) : void 0;
+  const lane = values.lane ? stripQuotes3(values.lane) : void 0;
   const task = {
     id,
     label,
@@ -10265,6 +10265,155 @@ var pert = {
   }
 };
 
+// src/core/diagnostics.ts
+var ENGINE_BUG_NAMES = /* @__PURE__ */ new Set([
+  "ReferenceError",
+  "TypeError",
+  "RangeError"
+]);
+function diagnosticFromError(err) {
+  if (err instanceof Error) {
+    const anyErr = err;
+    const hasParseFields = typeof anyErr.line === "number";
+    const isEngineBug = !hasParseFields && ENGINE_BUG_NAMES.has(err.name);
+    const source = typeof anyErr.source === "string" ? anyErr.source : isEngineBug ? firstStackFrame(err.stack) : void 0;
+    return {
+      severity: "error",
+      code: isEngineBug ? "ENGINE_BUG" : "DSL_INVALID",
+      line: typeof anyErr.line === "number" ? anyErr.line : void 0,
+      column: typeof anyErr.column === "number" ? anyErr.column : void 0,
+      source,
+      message: isEngineBug ? `[engine bug: ${err.name}] ${err.message}` : err.message,
+      hint: typeof anyErr.hint === "string" ? anyErr.hint : isEngineBug ? "This looks like a Schematex internal error rather than a DSL syntax problem. Keep the failing DSL and file an issue." : void 0,
+      fatal: true
+    };
+  }
+  return {
+    severity: "error",
+    code: "UNKNOWN_THROW",
+    message: String(err),
+    fatal: true
+  };
+}
+function renderDiagnosticSvg(diagnostics, type, config = {}) {
+  const headline = type ? `${type} preview could not be rendered` : "Diagram preview could not be rendered";
+  const detail = diagnostics[0]?.message ?? "Schematex could not parse this DSL.";
+  const lines = wrapText3(detail, 88).slice(0, 5);
+  const source = diagnostics[0]?.source ? wrapText3(`Source: ${diagnostics[0].source}`, 88).slice(0, 2) : [];
+  const foot = "Strict validation failed before a diagram could be drawn.";
+  const width = 760;
+  const lineHeight = 20;
+  const height = 174 + (lines.length + source.length) * lineHeight;
+  const fontFamily = config.fontFamily ?? "system-ui, -apple-system, sans-serif";
+  const children = [
+    title(headline),
+    desc(`${headline}. ${detail}`),
+    el(
+      "style",
+      {},
+      `
+.schematex-preview-error { font-family: ${escapeXml(fontFamily)}; }
+.schematex-preview-error-frame { fill: #fff7ed; stroke: #c2410c; stroke-width: 1.5; }
+.schematex-preview-error-mark { fill: #c2410c; }
+.schematex-preview-error-title { fill: #7c2d12; font-size: 18px; font-weight: 600; }
+.schematex-preview-error-copy { fill: #431407; font-size: 13px; }
+.schematex-preview-error-muted { fill: #9a3412; font-size: 12px; }
+`
+    ),
+    el("g", { class: "schematex-preview-error" }, [
+      rect({
+        x: 1,
+        y: 1,
+        width: width - 2,
+        height: height - 2,
+        rx: 6,
+        class: "schematex-preview-error-frame"
+      }),
+      rect({
+        x: 28,
+        y: 30,
+        width: 8,
+        height: 34,
+        rx: 4,
+        class: "schematex-preview-error-mark"
+      }),
+      rect({
+        x: 28,
+        y: 72,
+        width: 8,
+        height: 8,
+        rx: 4,
+        class: "schematex-preview-error-mark"
+      }),
+      text(
+        { x: 58, y: 49, class: "schematex-preview-error-title" },
+        headline
+      ),
+      text(
+        { x: 58, y: 76, class: "schematex-preview-error-muted" },
+        "The DSL is still available to repair or retry."
+      ),
+      ...renderRows(lines, 58, 112, lineHeight, "schematex-preview-error-copy"),
+      ...renderRows(
+        source,
+        58,
+        112 + lines.length * lineHeight + 10,
+        lineHeight,
+        "schematex-preview-error-muted"
+      ),
+      text(
+        { x: 58, y: height - 28, class: "schematex-preview-error-muted" },
+        foot
+      )
+    ])
+  ];
+  return svgRoot(
+    {
+      width,
+      height,
+      viewBox: `0 0 ${width} ${height}`,
+      role: "img",
+      "aria-label": headline,
+      "data-schematex-status": "invalid"
+    },
+    children
+  );
+}
+function renderRows(rows, x, y, lineHeight, className) {
+  return rows.map(
+    (row, idx) => text({ x, y: y + idx * lineHeight, class: className }, row)
+  );
+}
+function wrapText3(value, max) {
+  const words = value.replace(/\s+/g, " ").trim().split(" ");
+  const rows = [];
+  let current = "";
+  for (const word of words) {
+    if (!current) {
+      current = word;
+      continue;
+    }
+    if (current.length + word.length + 1 <= max) {
+      current += ` ${word}`;
+      continue;
+    }
+    rows.push(current);
+    current = word;
+  }
+  if (current) rows.push(current);
+  return rows.length > 0 ? rows : [value];
+}
+function firstStackFrame(stack) {
+  if (!stack) return void 0;
+  for (const line2 of stack.split("\n")) {
+    const trimmed = line2.trim();
+    if (trimmed.startsWith("at ")) {
+      return trimmed.replace(/\((?:.*\/)?([^/]+)\)/, "($1)");
+    }
+  }
+  return void 0;
+}
+
 // src/diagrams/mindmap/inline.ts
 var RE_TASK = /^\[( |x|X)\]\s+(.*)$/;
 function tokenizeInline(raw) {
@@ -11234,7 +11383,7 @@ function newAST() {
     config: { ...DEFAULT_CONFIG }
   };
 }
-function stripQuotes3(s) {
+function stripQuotes4(s) {
   const t = s.trim();
   if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
     return t.slice(1, -1);
@@ -11270,7 +11419,7 @@ function parseAxis(raw) {
 function parseNumberList2(raw) {
   const t = raw.trim();
   const inner = t.startsWith("[") && t.endsWith("]") ? t.slice(1, -1) : t;
-  return inner.split(",").map((s) => stripQuotes3(s.trim())).filter((s) => s.length > 0);
+  return inner.split(",").map((s) => stripQuotes4(s.trim())).filter((s) => s.length > 0);
 }
 function parseProperties2(raw, point) {
   let i = 0;
@@ -11385,7 +11534,7 @@ function parseHeader2(line2, ast) {
     ast.cols = Number(heatMatch[1]);
     ast.rows = Number(heatMatch[2]);
     const title2 = heatMatch[3].trim();
-    if (title2) ast.title = stripQuotes3(title2);
+    if (title2) ast.title = stripQuotes4(title2);
     return void 0;
   }
   const corrMatch = rest.match(/^correlation\s*(?:(\d+)\s*x\s*(\d+))?\s*(.*)$/i);
@@ -11397,7 +11546,7 @@ function parseHeader2(line2, ast) {
       ast.rows = Number(corrMatch[2]);
     }
     const title2 = corrMatch[3].trim();
-    if (title2) ast.title = stripQuotes3(title2);
+    if (title2) ast.title = stripQuotes4(title2);
     return void 0;
   }
   const tokenMatch = rest.match(/^([a-zA-Z0-9_-]+)\s*(.*)$/);
@@ -11405,13 +11554,13 @@ function parseHeader2(line2, ast) {
     const tok = tokenMatch[1].toLowerCase();
     const remainder = tokenMatch[2].trim();
     if (TEMPLATE_NAMES.has(tok)) {
-      if (remainder) ast.title = stripQuotes3(remainder);
+      if (remainder) ast.title = stripQuotes4(remainder);
       return tok;
     }
     if (rest.startsWith('"') || rest.startsWith("'")) {
-      ast.title = stripQuotes3(rest);
+      ast.title = stripQuotes4(rest);
     } else if (rest.length > 0) {
-      ast.title = stripQuotes3(rest);
+      ast.title = stripQuotes4(rest);
     }
   }
   return void 0;
@@ -11447,7 +11596,7 @@ function parseMatrix(text2) {
       inConfig = false;
     }
     if (/^title\s*:/i.test(line2)) {
-      st.ast.title = stripQuotes3(line2.replace(/^title\s*:\s*/i, ""));
+      st.ast.title = stripQuotes4(line2.replace(/^title\s*:\s*/i, ""));
       continue;
     }
     if (/^x-axis\s*:/i.test(line2)) {
@@ -11532,7 +11681,7 @@ function parseMatrix(text2) {
     if (qShort) {
       const q = Number(qShort[1]);
       const labelRaw = qShort[2].trim();
-      const label = stripQuotes3(labelRaw);
+      const label = stripQuotes4(labelRaw);
       const cell = quadrantToCell(q);
       st.ast.cellLabels.push({ col: cell.col, row: cell.row, label });
       continue;
@@ -13420,10 +13569,10 @@ function renderEntity(e) {
         a.name
       )
     );
-    const markers3 = attrMarkers(a);
+    const markers4 = attrMarkers(a);
     const markerW = 26;
     const markerGap = 4;
-    const markersBlockW = markers3.length * markerW + (markers3.length - 1) * markerGap;
+    const markersBlockW = markers4.length * markerW + (markers4.length - 1) * markerGap;
     const markersStartX = e.x + e.width - C2.ENTITY_PADDING_X - markersBlockW;
     if (a.type) {
       body.push(
@@ -13438,8 +13587,8 @@ function renderEntity(e) {
         )
       );
     }
-    for (let j = 0; j < markers3.length; j++) {
-      const m = markers3[j];
+    for (let j = 0; j < markers4.length; j++) {
+      const m = markers4[j];
       const px = markersStartX + j * (markerW + markerGap);
       body.push(
         rect({
@@ -18613,6 +18762,1178 @@ var sfc = {
   }
 };
 
+// src/diagrams/sequence/parser.ts
+var SequenceParseError = class extends Error {
+  line;
+  constructor(message, line2) {
+    super(line2 ? `${message} (line ${line2})` : message);
+    this.name = "SequenceParseError";
+    this.line = line2;
+  }
+};
+var KINDS = /* @__PURE__ */ new Set([
+  "participant",
+  "actor",
+  "boundary",
+  "control",
+  "entity",
+  "database",
+  "collections",
+  "queue"
+]);
+var SIMPLE_FRAG = /* @__PURE__ */ new Set([
+  "opt",
+  "loop",
+  "break",
+  "critical",
+  "neg",
+  "ignore",
+  "consider",
+  "assert"
+]);
+var MULTI_FRAG = /* @__PURE__ */ new Set(["par", "seq", "strict"]);
+var MSGSET_FRAG = /* @__PURE__ */ new Set(["ignore", "consider"]);
+var ALL_FRAG = /* @__PURE__ */ new Set([
+  "alt",
+  ...SIMPLE_FRAG,
+  ...MULTI_FRAG
+]);
+var ARROW_RE = /(-->|->>|o->|-x|->)/;
+function arrowKind(token) {
+  switch (token) {
+    case "-->":
+      return "reply";
+    case "->>":
+      return "async";
+    case "o->":
+      return "found";
+    case "-x":
+      return "lost";
+    default:
+      return "sync";
+  }
+}
+function firstWord(s) {
+  const m = /^(\S+)/.exec(s);
+  return m ? m[1] : "";
+}
+function extractGuard(rest) {
+  const t = rest.trim();
+  if (!t) return void 0;
+  if (t.startsWith("[") && t.endsWith("]")) return t.slice(1, -1).trim();
+  if (t.startsWith("(") && t.endsWith(")")) return t.slice(1, -1).trim();
+  return t;
+}
+var SequenceParser = class {
+  lines;
+  i = 0;
+  order = [];
+  byId = /* @__PURE__ */ new Map();
+  warnings = [];
+  constructor(source) {
+    this.lines = source.split(/\r?\n/).map((raw, idx) => ({
+      text: raw.trim(),
+      n: idx + 1
+    }));
+  }
+  parse() {
+    const header = this.consumeHeader();
+    const ast = {
+      type: "sequence",
+      participants: [],
+      statements: [],
+      warnings: this.warnings
+    };
+    if (header.title) ast.title = header.title;
+    const statements = this.parseBlock();
+    const leftover = this.peek();
+    if (leftover) {
+      const fw = firstWord(leftover.text).toLowerCase();
+      throw new SequenceParseError(
+        `'${fw}' without a matching combined fragment`,
+        leftover.n
+      );
+    }
+    if (this.autonumberSpec) ast.autonumber = this.autonumberSpec;
+    ast.statements = statements;
+    ast.participants = this.order.map((id) => this.byId.get(id));
+    return ast;
+  }
+  autonumberSpec;
+  // ── line cursor ──────────────────────────────────────────────
+  peek() {
+    while (this.i < this.lines.length) {
+      const ln = this.lines[this.i];
+      if (ln.text === "" || ln.text.startsWith("#") || ln.text.startsWith("//")) {
+        this.i++;
+        continue;
+      }
+      return ln;
+    }
+    return null;
+  }
+  next() {
+    const ln = this.peek();
+    if (ln) this.i++;
+    return ln;
+  }
+  // ── header ───────────────────────────────────────────────────
+  consumeHeader() {
+    const ln = this.next();
+    if (!ln || !/^sequence\b/i.test(ln.text)) {
+      throw new SequenceParseError(
+        "A sequence diagram must start with the keyword 'sequence'",
+        ln?.n
+      );
+    }
+    const title2 = matchQuotedTitle(ln.text);
+    return title2 ? { title: title2 } : {};
+  }
+  // ── participants ─────────────────────────────────────────────
+  ensure(id, kind = "participant", line2) {
+    let p = this.byId.get(id);
+    if (!p) {
+      p = { id, name: id, kind, line: line2 };
+      this.byId.set(id, p);
+      this.order.push(id);
+    }
+    return p;
+  }
+  declare(line2) {
+    const fw = firstWord(line2.text);
+    const kind = fw.toLowerCase();
+    let rest = line2.text.slice(fw.length).trim();
+    let stereotype;
+    const stereoMatch = /«([^»]*)»|<<([^>]*)>>/.exec(rest);
+    if (stereoMatch) {
+      stereotype = (stereoMatch[1] ?? stereoMatch[2] ?? "").trim();
+      rest = (rest.slice(0, stereoMatch.index) + rest.slice(stereoMatch.index + stereoMatch[0].length)).trim();
+    }
+    let id;
+    let name;
+    const asMatch = /\sas\s/i.exec(rest);
+    if (asMatch) {
+      id = stripQuotes(rest.slice(0, asMatch.index).trim());
+      name = stripQuotes(rest.slice(asMatch.index + asMatch[0].length).trim());
+    } else {
+      id = stripQuotes(rest);
+      name = id;
+    }
+    if (!id) {
+      throw new SequenceParseError(`'${fw}' declaration needs a name`, line2.n);
+    }
+    const existing = this.byId.get(id);
+    if (existing) {
+      existing.kind = kind;
+      existing.name = name;
+      if (stereotype) existing.stereotype = stereotype;
+    } else {
+      const p = { id, name, kind, line: line2.n };
+      if (stereotype) p.stereotype = stereotype;
+      this.byId.set(id, p);
+      this.order.push(id);
+    }
+  }
+  // ── block / statement dispatch ───────────────────────────────
+  /** Parse statements until a terminator (`end`/`else`/`and`) or EOF. Terminators are left unconsumed. */
+  parseBlock() {
+    const out = [];
+    for (; ; ) {
+      const ln = this.peek();
+      if (!ln) break;
+      const fw = firstWord(ln.text).toLowerCase();
+      if (fw === "end" || fw === "else" || fw === "and") break;
+      if (KINDS.has(fw)) {
+        this.i++;
+        this.declare(ln);
+        continue;
+      }
+      if (ALL_FRAG.has(fw)) {
+        out.push(this.parseFragment(ln));
+        continue;
+      }
+      this.i++;
+      const stmt = this.parseSimpleStatement(ln);
+      if (stmt) out.push(stmt);
+    }
+    return out;
+  }
+  parseFragment(open) {
+    const fw = firstWord(open.text).toLowerCase();
+    this.i++;
+    let rest = open.text.slice(fw.length);
+    let messageSet;
+    if (MSGSET_FRAG.has(fw)) {
+      const bm = /\{([^}]*)\}/.exec(rest);
+      if (bm) {
+        messageSet = bm[1].split(",").map((s) => s.trim()).filter(Boolean);
+        rest = rest.slice(0, bm.index) + rest.slice(bm.index + bm[0].length);
+      }
+    }
+    const firstGuard = extractGuard(rest);
+    const operands = [
+      { guard: firstGuard, statements: this.parseBlock() }
+    ];
+    for (; ; ) {
+      const ln = this.peek();
+      if (!ln) {
+        throw new SequenceParseError(`Unterminated '${fw}' fragment`, open.n);
+      }
+      const term = firstWord(ln.text).toLowerCase();
+      if (term === "end") {
+        this.i++;
+        break;
+      }
+      if (term === "else") {
+        if (fw !== "alt") {
+          throw new SequenceParseError(
+            `'else' is only valid inside an 'alt' fragment, not '${fw}'`,
+            ln.n
+          );
+        }
+        this.i++;
+        operands.push({
+          guard: extractGuard(ln.text.slice(4)),
+          statements: this.parseBlock()
+        });
+        continue;
+      }
+      if (term === "and") {
+        if (!MULTI_FRAG.has(fw)) {
+          throw new SequenceParseError(
+            `'and' is only valid inside par/seq/strict, not '${fw}'`,
+            ln.n
+          );
+        }
+        this.i++;
+        const label = ln.text.slice(3).trim();
+        operands.push({
+          guard: label ? extractGuard(label) : void 0,
+          statements: this.parseBlock()
+        });
+        continue;
+      }
+      throw new SequenceParseError(`Unexpected '${term}' in '${fw}'`, ln.n);
+    }
+    const frag = { kind: "fragment", op: fw, operands, line: open.n };
+    if (messageSet && messageSet.length) frag.messageSet = messageSet;
+    return frag;
+  }
+  /** Non-fragment, non-participant statements. */
+  parseSimpleStatement(ln) {
+    const text2 = ln.text;
+    const fw = firstWord(text2).toLowerCase();
+    if (fw === "activate" || fw === "deactivate") {
+      const m = /^(?:de)?activate\s+(\S+)$/i.exec(text2);
+      if (!m) throw new SequenceParseError(`Malformed ${fw} statement`, ln.n);
+      this.ensure(m[1], "participant", ln.n);
+      return { kind: fw, id: m[1], line: ln.n };
+    }
+    if (fw === "note") {
+      return this.parseNote(ln);
+    }
+    if (fw === "ref") {
+      const m = /^ref\s+over\s+(.+?)\s*:\s*(.*)$/i.exec(text2);
+      if (!m) throw new SequenceParseError("Malformed ref (expected: ref over A, B : text)", ln.n);
+      const ids = m[1].split(",").map((s) => stripQuotes(s.trim())).filter(Boolean);
+      ids.forEach((id) => this.ensure(id, "participant", ln.n));
+      return { kind: "ref", ids, text: m[2].trim(), line: ln.n };
+    }
+    if (text2.startsWith("==")) {
+      const m = /^==\s*(.*?)\s*==\s*$/.exec(text2);
+      return { kind: "divider", text: m ? m[1].trim() : "", line: ln.n };
+    }
+    if (fw === "state") {
+      const m = /^state\s+(\S+)\s*:\s*(.*)$/i.exec(text2);
+      if (!m) throw new SequenceParseError("Malformed state invariant (expected: state A : text)", ln.n);
+      this.ensure(m[1], "participant", ln.n);
+      return { kind: "invariant", id: m[1], text: m[2].trim(), line: ln.n };
+    }
+    if (fw === "destroy") {
+      const m = /^destroy\s+(\S+)$/i.exec(text2);
+      if (!m) throw new SequenceParseError("Malformed destroy statement", ln.n);
+      this.ensure(m[1], "participant", ln.n);
+      return { kind: "destroy", id: m[1], line: ln.n };
+    }
+    if (fw === "autonumber") {
+      const m = /^autonumber(?:\s+(\d+))?(?:\s+(\d+))?$/i.exec(text2);
+      const start = m && m[1] ? parseInt(m[1], 10) : 1;
+      const step = m && m[2] ? parseInt(m[2], 10) : 1;
+      this.autonumberSpec = { start, step };
+      return null;
+    }
+    return this.parseMessage(ln);
+  }
+  parseNote(ln) {
+    const m = /^note\s+(over|left of|right of)\s+(.+?)\s*:\s*(.*)$/i.exec(ln.text);
+    if (!m) {
+      throw new SequenceParseError(
+        "Malformed note (expected: note over|left of|right of A[, B] : text)",
+        ln.n
+      );
+    }
+    const placementRaw = m[1].toLowerCase();
+    const placement = placementRaw === "over" ? "over" : placementRaw.startsWith("left") ? "left" : "right";
+    const ids = m[2].split(",").map((s) => stripQuotes(s.trim())).filter(Boolean);
+    ids.forEach((id) => this.ensure(id, "participant", ln.n));
+    return { kind: "note", placement, ids, text: m[3].trim(), line: ln.n };
+  }
+  parseMessage(ln) {
+    const text2 = ln.text;
+    const arrowMatch = ARROW_RE.exec(text2);
+    if (!arrowMatch) {
+      throw new SequenceParseError(`Cannot parse statement: "${text2}"`, ln.n);
+    }
+    const token = arrowMatch[1];
+    const at = arrowMatch.index;
+    const leftRaw = text2.slice(0, at);
+    let rightRaw = text2.slice(at + token.length);
+    let label;
+    const colon = rightRaw.indexOf(":");
+    if (colon >= 0) {
+      label = rightRaw.slice(colon + 1).trim();
+      rightRaw = rightRaw.slice(0, colon);
+    }
+    let activateTarget = false;
+    let deactivateSource = false;
+    let left = leftRaw.trim();
+    if (left.endsWith("+")) {
+      activateTarget = true;
+      left = left.slice(0, -1).trim();
+    } else if (left.endsWith("-")) {
+      deactivateSource = true;
+      left = left.slice(0, -1).trim();
+    }
+    let right = rightRaw.trim();
+    if (right.startsWith("+")) {
+      activateTarget = true;
+      right = right.slice(1).trim();
+    } else if (right.startsWith("-")) {
+      deactivateSource = true;
+      right = right.slice(1).trim();
+    }
+    const arrow = arrowKind(token);
+    let create = false;
+    if (right.startsWith("*")) {
+      create = true;
+      right = right.slice(1).trim();
+    }
+    const from = arrow === "found" ? "" : stripQuotes(left);
+    const to = arrow === "lost" ? "" : stripQuotes(right);
+    if (from) this.ensure(from, "participant", ln.n);
+    if (to) {
+      const p = this.ensure(to, "participant", ln.n);
+      if (create) p.createdInline = true;
+    }
+    const msg = {
+      kind: "message",
+      from,
+      to,
+      arrow,
+      line: ln.n
+    };
+    if (label) msg.label = label;
+    if (activateTarget) msg.activateTarget = true;
+    if (deactivateSource) msg.deactivateSource = true;
+    if (create) msg.create = true;
+    return msg;
+  }
+};
+function parseSequence(text2) {
+  return new SequenceParser(text2).parse();
+}
+
+// src/diagrams/sequence/layout.ts
+var SEQ_CONST = {
+  HEAD_W_MIN: 90,
+  HEAD_H: 38,
+  HEAD_PAD_X: 14,
+  LIFELINE_GAP: 140,
+  LEFT_MARGIN: 24,
+  RIGHT_PAD: 28,
+  TOP_PAD: 16,
+  HEAD_TO_FIRST: 30,
+  EVENT_GAP: 38,
+  BOTTOM_PAD: 30,
+  SELF_GAP: 30,
+  SELF_LOOP_W: 48,
+  ACT_W: 10,
+  ACT_NEST_DX: 6,
+  ACT_STEP: 30,
+  FRAG_PAD_X: 10,
+  FRAG_LABEL_H: 18,
+  FRAG_PAD_TOP: 16,
+  FRAG_PAD_BOTTOM: 12,
+  FRAG_GAP_BEFORE: 12,
+  FRAG_OPERAND_GAP: 18,
+  FRAG_NEST_INSET: 8,
+  REF_H: 40,
+  REF_GAP_BEFORE: 12,
+  NOTE_GAP_BEFORE: 10,
+  NOTE_PAD: 8,
+  NOTE_MIN_W: 70,
+  NOTE_LINE_H: 15,
+  NOTE_SIDE_GAP: 16,
+  DIV_H: 26,
+  DIV_GAP_BEFORE: 8,
+  INV_GAP_BEFORE: 10,
+  INV_PAD: 10,
+  INV_H: 24,
+  LABEL_GAP_PAD: 26,
+  LOST_LEN: 72
+};
+var LABEL_SIZE = 11;
+var HEAD_TEXT_SIZE = 12.5;
+function textWidth(s, size) {
+  let w = 0;
+  for (const ch of s) {
+    w += /[⺀-￿]/.test(ch) ? size : size * 0.55;
+  }
+  return w;
+}
+var SequenceLayout = class {
+  ast;
+  lifelines = [];
+  colOf = /* @__PURE__ */ new Map();
+  llById = /* @__PURE__ */ new Map();
+  x = [];
+  headW = [];
+  y = 0;
+  open = /* @__PURE__ */ new Map();
+  colAccStack = [];
+  messages = [];
+  activations = [];
+  fragments = [];
+  refs = [];
+  notes = [];
+  dividers = [];
+  invariants = [];
+  destroys = [];
+  warnings = [];
+  autoCounter = null;
+  contentRight = 0;
+  constructor(ast) {
+    this.ast = ast;
+  }
+  run() {
+    this.buildColumns();
+    if (this.ast.autonumber) this.autoCounter = this.ast.autonumber.start;
+    const headBottom = SEQ_CONST.TOP_PAD + SEQ_CONST.HEAD_H;
+    this.y = headBottom + SEQ_CONST.HEAD_TO_FIRST - SEQ_CONST.EVENT_GAP;
+    this.walk(this.ast.statements, 0);
+    const bottomY = this.y + SEQ_CONST.EVENT_GAP;
+    for (const [id, stack] of this.open) {
+      while (stack.length) {
+        const b = stack.pop();
+        this.activations.push({ id, x: b.x, yTop: b.yTop, yBottom: bottomY, level: b.level });
+      }
+    }
+    const bodyBottom = bottomY + SEQ_CONST.BOTTOM_PAD;
+    for (const ll of this.lifelines) {
+      if (!ll.destroyed) ll.axisBottom = bodyBottom;
+    }
+    const lastCenter = this.x[this.x.length - 1] ?? SEQ_CONST.LEFT_MARGIN;
+    const lastHalf = (this.headW[this.headW.length - 1] ?? SEQ_CONST.HEAD_W_MIN) / 2;
+    this.contentRight = Math.max(this.contentRight, lastCenter + lastHalf);
+    const width = Math.round(this.contentRight + SEQ_CONST.RIGHT_PAD);
+    const height = Math.round(bodyBottom);
+    for (const d of this.dividers) d.width = width;
+    const result = {
+      width,
+      height,
+      lifelines: this.lifelines,
+      messages: this.messages,
+      activations: this.activations,
+      fragments: this.fragments,
+      refs: this.refs,
+      notes: this.notes,
+      dividers: this.dividers,
+      invariants: this.invariants,
+      destroys: this.destroys,
+      warnings: this.warnings.concat(this.ast.warnings),
+      ast: this.ast
+    };
+    if (this.ast.title) result.title = this.ast.title;
+    return result;
+  }
+  // ── horizontal pass ──────────────────────────────────────────
+  buildColumns() {
+    const ps = this.ast.participants;
+    this.headW = ps.map(
+      (p) => Math.max(SEQ_CONST.HEAD_W_MIN, Math.ceil(textWidth(p.name, HEAD_TEXT_SIZE)) + SEQ_CONST.HEAD_PAD_X * 2)
+    );
+    ps.forEach((p, i) => this.colOf.set(p.id, i));
+    const n = ps.length;
+    const gaps = new Array(Math.max(0, n - 1)).fill(SEQ_CONST.LIFELINE_GAP);
+    for (let k = 0; k < gaps.length; k++) {
+      gaps[k] = Math.max(gaps[k], this.headW[k] / 2 + this.headW[k + 1] / 2 + 28);
+    }
+    const msgs = collectMessages(this.ast.statements);
+    for (const m of msgs) {
+      const label = m.label ?? "";
+      const w = textWidth(label, LABEL_SIZE) + SEQ_CONST.LABEL_GAP_PAD;
+      const cf = this.colOf.get(m.from);
+      const ct = this.colOf.get(m.to);
+      if (cf === void 0 && ct === void 0) continue;
+      if (cf === void 0 || ct === void 0) continue;
+      if (cf === ct) {
+        if (cf < gaps.length) gaps[cf] = Math.max(gaps[cf], SEQ_CONST.SELF_LOOP_W + w);
+        continue;
+      }
+      const i = Math.min(cf, ct);
+      const j = Math.max(cf, ct);
+      if (j === i + 1) {
+        gaps[i] = Math.max(gaps[i], w);
+      } else {
+        let span = 0;
+        for (let k = i; k < j; k++) span += gaps[k];
+        if (span < w) {
+          const add = (w - span) / (j - i);
+          for (let k = i; k < j; k++) gaps[k] += add;
+        }
+      }
+    }
+    this.x = new Array(n);
+    let cx = SEQ_CONST.LEFT_MARGIN + (this.headW[0] ?? SEQ_CONST.HEAD_W_MIN) / 2;
+    for (let i = 0; i < n; i++) {
+      this.x[i] = cx;
+      if (i < gaps.length) cx += gaps[i];
+    }
+    ps.forEach((p, i) => {
+      const created = p.createdInline === true;
+      const headY = created ? -1 : SEQ_CONST.TOP_PAD;
+      const ll = {
+        participant: p,
+        index: i,
+        x: this.x[i],
+        headX: this.x[i] - this.headW[i] / 2,
+        headY,
+        headW: this.headW[i],
+        headH: SEQ_CONST.HEAD_H,
+        axisTop: created ? -1 : SEQ_CONST.TOP_PAD + SEQ_CONST.HEAD_H,
+        axisBottom: 0,
+        destroyed: false
+      };
+      this.lifelines.push(ll);
+      this.llById.set(p.id, ll);
+    });
+  }
+  // ── column accounting (for fragment extents) ─────────────────
+  touch(col) {
+    if (col === void 0) return;
+    for (const acc of this.colAccStack) {
+      if (col < acc.min) acc.min = col;
+      if (col > acc.max) acc.max = col;
+    }
+  }
+  noteRight(x, w) {
+    this.contentRight = Math.max(this.contentRight, x + w);
+  }
+  // ── activation bars ──────────────────────────────────────────
+  openBar(id) {
+    const col = this.colOf.get(id);
+    if (col === void 0) return;
+    const stack = this.open.get(id) ?? [];
+    const level = stack.length;
+    const x = this.x[col] - SEQ_CONST.ACT_W / 2 + level * SEQ_CONST.ACT_NEST_DX;
+    stack.push({ x, yTop: this.y, level });
+    this.open.set(id, stack);
+  }
+  closeBar(id) {
+    const stack = this.open.get(id);
+    if (!stack || stack.length === 0) {
+      this.warnings.push(`deactivate '${id}' with no matching activation`);
+      return;
+    }
+    const b = stack.pop();
+    this.activations.push({ id, x: b.x, yTop: b.yTop, yBottom: this.y, level: b.level });
+  }
+  faceEdge(id, col, towardRight, extraLevel = 0) {
+    const stack = this.open.get(id) ?? [];
+    const levels = stack.length + extraLevel;
+    if (levels <= 0) return this.x[col];
+    if (!towardRight) return this.x[col] - SEQ_CONST.ACT_W / 2;
+    return this.x[col] + SEQ_CONST.ACT_W / 2 + (levels - 1) * SEQ_CONST.ACT_NEST_DX;
+  }
+  // ── vertical walk ────────────────────────────────────────────
+  walk(stmts, depth) {
+    for (const s of stmts) {
+      switch (s.kind) {
+        case "message":
+          this.placeMessage(s);
+          break;
+        case "activate":
+          this.y += SEQ_CONST.ACT_STEP;
+          this.openBar(s.id);
+          this.touch(this.colOf.get(s.id));
+          break;
+        case "deactivate":
+          this.y += SEQ_CONST.ACT_STEP;
+          this.closeBar(s.id);
+          this.touch(this.colOf.get(s.id));
+          break;
+        case "note":
+          this.placeNote(s);
+          break;
+        case "ref":
+          this.placeRef(s.ids, s.text);
+          break;
+        case "divider":
+          this.y += SEQ_CONST.DIV_GAP_BEFORE;
+          this.dividers.push({ text: s.text, y: this.y + SEQ_CONST.DIV_H / 2, width: 0 });
+          this.y += SEQ_CONST.DIV_H;
+          break;
+        case "invariant":
+          this.placeInvariant(s.id, s.text);
+          break;
+        case "destroy":
+          this.placeDestroy(s.id);
+          break;
+        case "fragment":
+          this.placeFragment(s.op, s.operands, depth, s.messageSet);
+          break;
+      }
+    }
+  }
+  nextNumber() {
+    if (this.autoCounter === null || !this.ast.autonumber) return void 0;
+    const n = this.autoCounter;
+    this.autoCounter += this.ast.autonumber.step;
+    return n;
+  }
+  placeMessage(m) {
+    this.y += SEQ_CONST.EVENT_GAP;
+    const y = this.y;
+    const cf = this.colOf.get(m.from);
+    const ct = this.colOf.get(m.to);
+    const self = m.from !== "" && m.from === m.to;
+    let x1;
+    let x2;
+    if (m.arrow === "found") {
+      const c = ct;
+      x2 = this.faceEdge(m.to, c, false);
+      x1 = x2 - SEQ_CONST.LOST_LEN;
+    } else if (m.arrow === "lost") {
+      const c = cf;
+      x1 = this.faceEdge(m.from, c, true);
+      x2 = x1 + SEQ_CONST.LOST_LEN;
+    } else if (self) {
+      const c = cf;
+      x1 = this.faceEdge(m.from, c, true);
+      x2 = x1 + SEQ_CONST.SELF_LOOP_W;
+    } else {
+      const fromRight = (ct ?? 0) > (cf ?? 0);
+      x1 = this.faceEdge(m.from, cf, fromRight);
+      if (m.create) {
+        const halfW = this.headW[ct] / 2;
+        x2 = fromRight ? this.x[ct] - halfW : this.x[ct] + halfW;
+      } else {
+        x2 = this.faceEdge(m.to, ct, !fromRight, m.activateTarget ? 1 : 0);
+      }
+    }
+    const row = { message: m, y, x1, x2, self };
+    const num = this.nextNumber();
+    if (num !== void 0) row.number = num;
+    if (self) {
+      row.selfBottomY = y + SEQ_CONST.SELF_GAP;
+      this.y = row.selfBottomY;
+    }
+    this.messages.push(row);
+    this.contentRight = Math.max(this.contentRight, x1, x2);
+    this.touch(cf);
+    this.touch(ct);
+    if (m.create && ct !== void 0) {
+      const ll = this.llById.get(m.to);
+      ll.headY = y - SEQ_CONST.HEAD_H / 2;
+      ll.axisTop = ll.headY + SEQ_CONST.HEAD_H;
+    }
+    if (m.activateTarget && ct !== void 0) this.openBar(m.to);
+    if (m.deactivateSource && cf !== void 0) this.closeBar(m.from);
+  }
+  placeNote(note) {
+    this.y += SEQ_CONST.NOTE_GAP_BEFORE;
+    const lines = note.text.split(/<br\s*\/?>|\\n/);
+    const textW = lines.reduce((mx, l) => Math.max(mx, textWidth(l, LABEL_SIZE)), 0);
+    const w = Math.max(SEQ_CONST.NOTE_MIN_W, Math.ceil(textW) + SEQ_CONST.NOTE_PAD * 2);
+    const h = lines.length * SEQ_CONST.NOTE_LINE_H + SEQ_CONST.NOTE_PAD * 2;
+    const top = this.y;
+    const cols = note.ids.map((id) => this.colOf.get(id)).filter((c) => c !== void 0);
+    cols.forEach((c) => this.touch(c));
+    let x;
+    let boxW = w;
+    if (note.placement === "over" && cols.length >= 2) {
+      const a = this.x[Math.min(...cols)];
+      const b = this.x[Math.max(...cols)];
+      const span = b - a + this.headW[Math.min(...cols)] / 2 + this.headW[Math.max(...cols)] / 2;
+      boxW = Math.max(w, span);
+      x = (a + b) / 2 - boxW / 2;
+    } else if (note.placement === "left" && cols.length) {
+      x = this.x[cols[0]] - SEQ_CONST.NOTE_SIDE_GAP - w;
+    } else if (note.placement === "right" && cols.length) {
+      x = this.x[cols[0]] + SEQ_CONST.NOTE_SIDE_GAP;
+    } else {
+      const c = cols[0] ?? 0;
+      x = this.x[c] - w / 2;
+    }
+    this.notes.push({ note, x, y: top, width: boxW, height: h });
+    this.noteRight(x, boxW);
+    this.y = top + h;
+  }
+  placeRef(ids, text2) {
+    this.y += SEQ_CONST.REF_GAP_BEFORE;
+    const cols = ids.map((id) => this.colOf.get(id)).filter((c) => c !== void 0);
+    cols.forEach((c) => this.touch(c));
+    const minC = cols.length ? Math.min(...cols) : 0;
+    const maxC = cols.length ? Math.max(...cols) : 0;
+    const left = this.x[minC] - SEQ_CONST.FRAG_PAD_X;
+    const right = this.x[maxC] + SEQ_CONST.FRAG_PAD_X;
+    const top = this.y;
+    this.refs.push({ text: text2, x: left, y: top, width: right - left, height: SEQ_CONST.REF_H });
+    this.noteRight(left, right - left);
+    this.y = top + SEQ_CONST.REF_H;
+  }
+  placeInvariant(id, text2) {
+    this.y += SEQ_CONST.INV_GAP_BEFORE;
+    const col = this.colOf.get(id);
+    this.touch(col);
+    const w = Math.ceil(textWidth(text2, LABEL_SIZE)) + SEQ_CONST.INV_PAD * 2;
+    const cx = col !== void 0 ? this.x[col] : SEQ_CONST.LEFT_MARGIN;
+    const top = this.y;
+    this.invariants.push({ text: text2, cx, y: top, width: w, height: SEQ_CONST.INV_H });
+    this.noteRight(cx - w / 2, w);
+    this.y = top + SEQ_CONST.INV_H;
+  }
+  placeDestroy(id) {
+    this.y += SEQ_CONST.EVENT_GAP / 2;
+    const ll = this.llById.get(id);
+    const col = this.colOf.get(id);
+    if (ll && col !== void 0) {
+      ll.destroyed = true;
+      ll.axisBottom = this.y;
+      this.destroys.push({ x: this.x[col], y: this.y });
+      this.touch(col);
+    }
+  }
+  placeFragment(op, operands, depth, messageSet) {
+    const frameTop = this.y + SEQ_CONST.FRAG_GAP_BEFORE;
+    const acc = { min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY };
+    this.colAccStack.push(acc);
+    const operandGeom = [];
+    this.y = frameTop + SEQ_CONST.FRAG_LABEL_H + SEQ_CONST.FRAG_PAD_TOP - SEQ_CONST.EVENT_GAP;
+    const firstGeom = {};
+    if (operands[0]?.guard) firstGeom.guard = operands[0].guard;
+    operandGeom.push(firstGeom);
+    this.walk(operands[0]?.statements ?? [], depth + 1);
+    for (let oi = 1; oi < operands.length; oi++) {
+      const sepY = this.y + SEQ_CONST.FRAG_OPERAND_GAP;
+      const geom = { sepY };
+      if (operands[oi].guard) geom.guard = operands[oi].guard;
+      operandGeom.push(geom);
+      this.y = sepY + SEQ_CONST.FRAG_PAD_TOP - SEQ_CONST.EVENT_GAP;
+      this.walk(operands[oi].statements, depth + 1);
+    }
+    const frameBottom = this.y + SEQ_CONST.FRAG_PAD_BOTTOM;
+    this.colAccStack.pop();
+    let minC = acc.min;
+    let maxC = acc.max;
+    if (!isFinite(minC)) {
+      minC = 0;
+      maxC = Math.max(0, this.lifelines.length - 1);
+    }
+    const inset = depth * SEQ_CONST.FRAG_NEST_INSET;
+    let left = this.x[minC] - SEQ_CONST.FRAG_PAD_X + inset;
+    let right = this.x[maxC] + SEQ_CONST.FRAG_PAD_X - inset;
+    if (right - left < 40) {
+      const mid = (left + right) / 2;
+      left = mid - 20;
+      right = mid + 20;
+    }
+    const frame = {
+      op,
+      x: left,
+      y: frameTop,
+      width: right - left,
+      height: frameBottom - frameTop,
+      operands: operandGeom
+    };
+    if (messageSet && messageSet.length) frame.messageSet = messageSet;
+    this.fragments.push(frame);
+    this.noteRight(left, right - left);
+    this.y = frameBottom;
+  }
+};
+function collectMessages(stmts) {
+  const out = [];
+  for (const s of stmts) {
+    if (s.kind === "message") out.push(s);
+    else if (s.kind === "fragment") {
+      for (const op of s.operands) out.push(...collectMessages(op.statements));
+    }
+  }
+  return out;
+}
+function layoutSequence(ast) {
+  return new SequenceLayout(ast).run();
+}
+
+// src/diagrams/sequence/renderer.ts
+var HEAD = "#e8f0fb";
+var HEAD_STROKE = "#5b85c0";
+function buildCss7(t) {
+  return `
+.sx-seq { font-family: system-ui, -apple-system, sans-serif; }
+.sx-seq-axis { stroke: ${t.neutral}; stroke-width: 1; stroke-dasharray: 4 4; }
+.sx-seq-head rect, .sx-seq-head path { fill: ${HEAD}; stroke: ${HEAD_STROKE}; stroke-width: 1.4; }
+.sx-seq-head-name { font: 600 12.5px sans-serif; fill: ${t.text}; }
+.sx-seq-head-stereo { font: italic 10px sans-serif; fill: ${t.textMuted}; }
+.sx-seq-actor line, .sx-seq-actor circle { stroke: ${t.stroke}; stroke-width: 1.6; fill: none; stroke-linecap: round; }
+.sx-seq-actor-head { fill: ${t.bg}; }
+.sx-seq-icon { fill: ${t.bg}; stroke: ${HEAD_STROKE}; stroke-width: 1.6; }
+.sx-seq-icon-line { stroke: ${HEAD_STROKE}; stroke-width: 1.6; fill: none; stroke-linecap: round; }
+.sx-seq-icon-fill { fill: ${HEAD_STROKE}; stroke: none; }
+.sx-seq-act { fill: ${t.bg}; stroke: ${HEAD_STROKE}; stroke-width: 1.2; }
+.sx-seq-msg { stroke: ${t.stroke}; stroke-width: 1.5; fill: none; }
+.sx-seq-msg-reply { stroke: ${t.stroke}; stroke-width: 1.4; fill: none; stroke-dasharray: 6 4; }
+.sx-seq-msg-label { font: 11px sans-serif; fill: ${t.text}; }
+.sx-seq-msg-num { font: 600 10px sans-serif; fill: ${t.textMuted}; }
+.sx-seq-endpoint { fill: ${t.stroke}; }
+.sx-seq-frame { fill: none; stroke: ${t.neutral}; stroke-width: 1.2; }
+.sx-seq-frame-neg { fill: ${t.negative}; fill-opacity: 0.06; }
+.sx-seq-frame-sep { stroke: ${t.neutral}; stroke-width: 1; stroke-dasharray: 5 4; }
+.sx-seq-frame-tab { fill: ${t.fillMuted}; stroke: ${t.neutral}; stroke-width: 1.2; }
+.sx-seq-frame-op { font: 700 11px sans-serif; fill: ${t.text}; }
+.sx-seq-guard { font: italic 10.5px sans-serif; fill: ${t.textMuted}; }
+.sx-seq-ref-name { font: 600 12px sans-serif; fill: ${t.text}; }
+.sx-seq-note rect { fill: #fdf6da; stroke: #d9c97e; stroke-width: 1.1; }
+.sx-seq-note path { fill: #efe2a6; stroke: #d9c97e; stroke-width: 1.1; }
+.sx-seq-note-text { font: 11px sans-serif; fill: ${t.text}; }
+.sx-seq-div line { stroke: ${t.neutral}; stroke-width: 1; }
+.sx-seq-div rect { fill: ${t.fillMuted}; stroke: ${t.neutral}; stroke-width: 1; }
+.sx-seq-div-text { font: 600 11px sans-serif; fill: ${t.textMuted}; }
+.sx-seq-inv rect { fill: ${t.bg}; stroke: ${t.neutral}; stroke-width: 1.1; }
+.sx-seq-inv-text { font: italic 10.5px sans-serif; fill: ${t.textMuted}; }
+.sx-seq-destroy { stroke: ${t.negative}; stroke-width: 2; }
+.sx-seq-title { font: 700 16px sans-serif; fill: ${t.text}; }
+`.trim();
+}
+function markers3(t) {
+  return defs([
+    el(
+      "marker",
+      { id: "sx-seq-filled", viewBox: "0 0 12 10", refX: 10, refY: 5, markerWidth: 11, markerHeight: 9, orient: "auto" },
+      [el("polygon", { points: "0,0 11,5 0,10", fill: t.stroke })]
+    ),
+    el(
+      "marker",
+      { id: "sx-seq-open", viewBox: "0 0 12 10", refX: 10, refY: 5, markerWidth: 12, markerHeight: 10, orient: "auto" },
+      [el("polyline", { points: "0,0 10,5 0,10", fill: "none", stroke: t.stroke, "stroke-width": 1.5 })]
+    )
+  ]);
+}
+var CHAR_W2 = 6;
+function renderLifeline(ll) {
+  const parts = [];
+  parts.push(line({ class: "sx-seq-axis", x1: ll.x, y1: ll.axisTop, x2: ll.x, y2: ll.axisBottom }));
+  parts.push(renderHead(ll));
+  return group({ class: "sx-seq-lifeline", "data-id": ll.participant.id, "data-kind": ll.participant.kind }, parts);
+}
+function renderHead(ll) {
+  const p = ll.participant;
+  const cx = ll.x;
+  const stereo = p.stereotype ? `\xAB${p.stereotype}\xBB` : null;
+  if (p.kind === "actor") {
+    const topY = ll.headY;
+    const fig = [];
+    if (stereo) {
+      fig.push(text({ class: "sx-seq-head-stereo", x: cx, y: topY - 4, "text-anchor": "middle" }, stereo));
+    }
+    fig.push(
+      circle({ class: "sx-seq-actor-head", cx, cy: topY + 6, r: 4.5 }),
+      line({ x1: cx, y1: topY + 10, x2: cx, y2: topY + 22 }),
+      line({ x1: cx - 8, y1: topY + 14, x2: cx + 8, y2: topY + 14 }),
+      line({ x1: cx, y1: topY + 22, x2: cx - 7, y2: topY + 32 }),
+      line({ x1: cx, y1: topY + 22, x2: cx + 7, y2: topY + 32 }),
+      text({ class: "sx-seq-head-name", x: cx, y: topY + 44, "text-anchor": "middle" }, p.name)
+    );
+    return group({ class: "sx-seq-actor sx-seq-head" }, fig);
+  }
+  if (p.kind === "boundary" || p.kind === "control" || p.kind === "entity") {
+    return renderRobustnessIcon(ll, stereo);
+  }
+  if (p.kind === "database") {
+    const w = ll.headW;
+    const h = ll.headH;
+    const x = ll.headX;
+    const y = ll.headY;
+    const ry = 5;
+    const d = `M ${x} ${y + ry} a ${w / 2} ${ry} 0 0 1 ${w} 0 v ${h - 2 * ry} a ${w / 2} ${ry} 0 0 1 ${-w} 0 Z M ${x} ${y + ry} a ${w / 2} ${ry} 0 0 0 ${w} 0`;
+    return group({ class: "sx-seq-head" }, [
+      path({ d }),
+      text({ class: "sx-seq-head-name", x: cx, y: y + h / 2 + 6, "text-anchor": "middle" }, p.name)
+    ]);
+  }
+  const parts = [
+    rect({ x: ll.headX, y: ll.headY, width: ll.headW, height: ll.headH, rx: 3, ry: 3 })
+  ];
+  const stereoText = stereo ?? (p.kind === "collections" || p.kind === "queue" ? `\xAB${p.kind}\xBB` : null);
+  if (stereoText) {
+    parts.push(
+      text({ class: "sx-seq-head-stereo", x: cx, y: ll.headY + 14, "text-anchor": "middle" }, stereoText)
+    );
+    parts.push(
+      text({ class: "sx-seq-head-name", x: cx, y: ll.headY + 28, "text-anchor": "middle" }, p.name)
+    );
+  } else {
+    parts.push(
+      text({ class: "sx-seq-head-name", x: cx, y: ll.headY + ll.headH / 2 + 5, "text-anchor": "middle" }, p.name)
+    );
+  }
+  return group({ class: "sx-seq-head" }, parts);
+}
+function renderRobustnessIcon(ll, stereo) {
+  const p = ll.participant;
+  const cx = ll.x;
+  const R = 11;
+  const cy = ll.headY + 14;
+  const parts = [];
+  if (stereo) {
+    parts.push(text({ class: "sx-seq-head-stereo", x: cx, y: ll.headY - 2, "text-anchor": "middle" }, stereo));
+  }
+  parts.push(circle({ class: "sx-seq-icon", cx, cy, r: R }));
+  if (p.kind === "boundary") {
+    const bx = cx - R - 9;
+    parts.push(line({ class: "sx-seq-icon-line", x1: bx, y1: cy - R, x2: bx, y2: cy + R }));
+    parts.push(line({ class: "sx-seq-icon-line", x1: bx, y1: cy, x2: cx - R, y2: cy }));
+  } else if (p.kind === "entity") {
+    parts.push(line({ class: "sx-seq-icon-line", x1: cx - R - 2, y1: cy + R + 1, x2: cx + R + 2, y2: cy + R + 1 }));
+  } else {
+    parts.push(
+      polygon({ class: "sx-seq-icon-fill", points: `${cx - 2},${cy - R - 6} ${cx + 5},${cy - R - 1} ${cx - 3},${cy - R + 2}` })
+    );
+  }
+  parts.push(text({ class: "sx-seq-head-name", x: cx, y: ll.headY + 44, "text-anchor": "middle" }, p.name));
+  return group({ class: "sx-seq-head sx-seq-icon-head", "data-icon": p.kind }, parts);
+}
+function renderActivation(a) {
+  const h = Math.max(6, a.yBottom - a.yTop);
+  return rect({
+    class: "sx-seq-act",
+    "data-id": a.id,
+    x: a.x,
+    y: a.yTop,
+    width: 10,
+    height: h
+  });
+}
+function renderMessage(m) {
+  const k = m.message.arrow;
+  const lineClass2 = k === "reply" ? "sx-seq-msg-reply" : "sx-seq-msg";
+  const markerEnd = k === "async" || k === "reply" ? "url(#sx-seq-open)" : "url(#sx-seq-filled)";
+  const parts = [];
+  if (m.self) {
+    const bottom = m.selfBottomY ?? m.y + 28;
+    const right = m.x2;
+    const d = `M ${m.x1} ${m.y} H ${right} V ${bottom} H ${m.x1}`;
+    parts.push(path({ class: lineClass2, d, "marker-end": markerEnd }));
+    if (m.message.label) {
+      parts.push(
+        text(
+          { class: "sx-seq-msg-label", x: right + 6, y: (m.y + bottom) / 2 + 3 },
+          numbered(m, m.message.label)
+        )
+      );
+    }
+  } else {
+    parts.push(line({ class: lineClass2, x1: m.x1, y1: m.y, x2: m.x2, y2: m.y, "marker-end": markerEnd }));
+    if (k === "lost") parts.push(circle({ class: "sx-seq-endpoint", cx: m.x2, cy: m.y, r: 4 }));
+    if (k === "found") parts.push(circle({ class: "sx-seq-endpoint", cx: m.x1, cy: m.y, r: 4 }));
+    if (m.message.label) {
+      const mid = (m.x1 + m.x2) / 2;
+      parts.push(
+        text(
+          { class: "sx-seq-msg-label", x: mid, y: m.y - 6, "text-anchor": "middle" },
+          numbered(m, m.message.label)
+        )
+      );
+    }
+  }
+  return group(
+    {
+      class: "sx-seq-message",
+      "data-kind": k,
+      "data-from": m.message.from,
+      "data-to": m.message.to
+    },
+    parts
+  );
+}
+function numbered(m, label) {
+  return m.number !== void 0 ? `${m.number}. ${label}` : label;
+}
+function tabWidth(f) {
+  return Math.max(40, f.op.length * 8 + 22);
+}
+function renderFragmentBox(f) {
+  const frameClass = f.op === "neg" ? "sx-seq-frame sx-seq-frame-neg" : "sx-seq-frame";
+  const parts = [
+    rect({ class: frameClass, x: f.x, y: f.y, width: f.width, height: f.height, rx: 2, ry: 2 })
+  ];
+  for (const op of f.operands) {
+    if (op.sepY !== void 0) {
+      parts.push(line({ class: "sx-seq-frame-sep", x1: f.x, y1: op.sepY, x2: f.x + f.width, y2: op.sepY }));
+    }
+  }
+  return group({ class: "sx-seq-fragment", "data-op": f.op }, parts);
+}
+function renderFragmentTab(f) {
+  const tabW = tabWidth(f);
+  const tabH = 18;
+  const fold = 6;
+  const tx = f.x;
+  const ty = f.y;
+  const tab = `M ${tx} ${ty} H ${tx + tabW} V ${ty + tabH - fold} L ${tx + tabW - fold} ${ty + tabH} H ${tx} Z`;
+  const parts = [
+    path({ class: "sx-seq-frame-tab", d: tab }),
+    text({ class: "sx-seq-frame-op", x: tx + 8, y: ty + 13 }, f.op)
+  ];
+  if (f.messageSet && f.messageSet.length) {
+    parts.push(
+      text({ class: "sx-seq-guard", x: tx + tabW + 8, y: ty + 13 }, `{${f.messageSet.join(", ")}}`)
+    );
+  }
+  f.operands.forEach((op, i) => {
+    if (!op.guard) return;
+    const gx = i === 0 ? f.x + tabW + 8 : f.x + 8;
+    const gy = i === 0 ? f.y + 13 : (op.sepY ?? f.y) + 14;
+    parts.push(text({ class: "sx-seq-guard", x: gx, y: gy }, `[${op.guard}]`));
+  });
+  return group({ class: "sx-seq-fragment-tab-g", "data-op": f.op }, parts);
+}
+function renderRef(r) {
+  const tabW = 40;
+  const tabH = 18;
+  const fold = 6;
+  const tab = `M ${r.x} ${r.y} H ${r.x + tabW} V ${r.y + tabH - fold} L ${r.x + tabW - fold} ${r.y + tabH} H ${r.x} Z`;
+  return group({ class: "sx-seq-fragment", "data-op": "ref" }, [
+    rect({ class: "sx-seq-frame", x: r.x, y: r.y, width: r.width, height: r.height, rx: 2, ry: 2 }),
+    path({ class: "sx-seq-frame-tab", d: tab }),
+    text({ class: "sx-seq-frame-op", x: r.x + 8, y: r.y + 13 }, "ref"),
+    text(
+      { class: "sx-seq-ref-name", x: r.x + r.width / 2, y: r.y + r.height / 2 + 8, "text-anchor": "middle" },
+      r.text
+    )
+  ]);
+}
+function renderNote2(nb) {
+  const fold = 8;
+  const x = nb.x;
+  const y = nb.y;
+  const w = nb.width;
+  const h = nb.height;
+  const body = `M ${x} ${y} H ${x + w - fold} L ${x + w} ${y + fold} V ${y + h} H ${x} Z`;
+  const corner = `M ${x + w - fold} ${y} V ${y + fold} H ${x + w} Z`;
+  const lines = nb.note.text.split(/<br\s*\/?>|\\n/);
+  const startY = y + h / 2 - (lines.length - 1) * 15 / 2 + 4;
+  const texts = lines.map(
+    (l, i) => text({ class: "sx-seq-note-text", x: x + w / 2, y: startY + i * 15, "text-anchor": "middle" }, l)
+  );
+  return group({ class: "sx-seq-note" }, [path({ d: body }), path({ d: corner }), ...texts]);
+}
+function renderDivider(d) {
+  const labelW = Math.max(60, d.text.length * CHAR_W2 + 24);
+  const cx = d.width / 2;
+  const parts = [
+    line({ x1: 8, y1: d.y, x2: cx - labelW / 2, y2: d.y }),
+    line({ x1: cx + labelW / 2, y1: d.y, x2: d.width - 8, y2: d.y }),
+    rect({ x: cx - labelW / 2, y: d.y - 11, width: labelW, height: 22, rx: 4, ry: 4 }),
+    text({ class: "sx-seq-div-text", x: cx, y: d.y + 4, "text-anchor": "middle" }, d.text)
+  ];
+  return group({ class: "sx-seq-div" }, parts);
+}
+function renderInvariant(iv) {
+  return group({ class: "sx-seq-inv" }, [
+    rect({ x: iv.cx - iv.width / 2, y: iv.y, width: iv.width, height: iv.height, rx: iv.height / 2, ry: iv.height / 2 }),
+    text({ class: "sx-seq-inv-text", x: iv.cx, y: iv.y + iv.height / 2 + 4, "text-anchor": "middle" }, `{${iv.text}}`)
+  ]);
+}
+function renderDestroy(d) {
+  const r = 7;
+  return group({ class: "sx-seq-destroy-g" }, [
+    line({ class: "sx-seq-destroy", x1: d.x - r, y1: d.y - r, x2: d.x + r, y2: d.y + r }),
+    line({ class: "sx-seq-destroy", x1: d.x - r, y1: d.y + r, x2: d.x + r, y2: d.y - r })
+  ]);
+}
+function renderSequenceLayout(layout, config) {
+  const t = resolveBaseTheme(config?.theme ?? "default");
+  const children = [];
+  const nMsg = layout.messages.length;
+  const nFrag = layout.fragments.length;
+  children.push(title(`Sequence Diagram${layout.title ? " \u2014 " + layout.title : ""}`));
+  children.push(
+    desc(
+      `${layout.lifelines.length} participants, ${nMsg} messages, ${nFrag} combined fragments.`
+    )
+  );
+  children.push(el("style", {}, buildCss7(t)));
+  children.push(markers3(t));
+  const titleBand = layout.title ? 32 : 0;
+  if (layout.title) {
+    children.push(
+      text({ x: layout.width / 2, y: 22, class: "sx-seq-title", "text-anchor": "middle" }, layout.title)
+    );
+  }
+  const body = [];
+  body.push(group({ class: "sx-seq-lifelines" }, layout.lifelines.map(renderLifeline)));
+  body.push(group({ class: "sx-seq-frames" }, layout.fragments.map(renderFragmentBox)));
+  body.push(group({ class: "sx-seq-acts" }, layout.activations.map(renderActivation)));
+  body.push(group({ class: "sx-seq-frame-tabs" }, layout.fragments.map(renderFragmentTab)));
+  body.push(group({ class: "sx-seq-refs" }, layout.refs.map(renderRef)));
+  body.push(group({ class: "sx-seq-messages" }, layout.messages.map(renderMessage)));
+  body.push(group({ class: "sx-seq-notes" }, layout.notes.map(renderNote2)));
+  body.push(group({ class: "sx-seq-divs" }, layout.dividers.map(renderDivider)));
+  body.push(group({ class: "sx-seq-invs" }, layout.invariants.map(renderInvariant)));
+  body.push(group({ class: "sx-seq-destroys" }, layout.destroys.map(renderDestroy)));
+  children.push(
+    titleBand ? group({ transform: `translate(0, ${titleBand})` }, body) : group({}, body)
+  );
+  const height = layout.height + titleBand;
+  return svgRoot(
+    {
+      class: "sx-seq",
+      role: "img",
+      "aria-label": escapeXml(layout.title ?? "UML sequence diagram"),
+      width: layout.width,
+      height,
+      viewBox: `0 0 ${layout.width} ${height}`,
+      "data-diagram-type": "sequence"
+    },
+    children
+  );
+}
+function renderSequence(textOrAst, config) {
+  const ast = typeof textOrAst === "string" ? parseSequence(textOrAst) : textOrAst;
+  const layout = layoutSequence(ast);
+  return renderSequenceLayout(layout, config);
+}
+
+// src/diagrams/sequence/index.ts
+var sequence = {
+  type: "sequence",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^sequence\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parseSequence,
+  render(text2, config) {
+    return renderSequence(text2, config);
+  }
+};
+
 // src/core/api.ts
 var plugins = [
   genogram,
@@ -18644,7 +19965,8 @@ var plugins = [
   sfc,
   prisma,
   usecase,
-  pert
+  pert,
+  sequence
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -18655,7 +19977,7 @@ function detectPlugin(text2, config) {
     if (plugin.detect(text2)) return plugin;
   }
   throw new Error(
-    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', or 'pert'."
+    "Cannot detect diagram type. Start your text with 'genogram', 'ecomap', 'pedigree', 'phylo', 'sociogram', 'timing', 'logic', 'circuit', 'blockdiagram', 'ladder', 'sld', 'entity-structure', 'fishbone', 'venn', 'flowchart', 'mindmap', 'matrix', 'orgchart', 'state', 'pid', 'erd', 'breadboard', 'bpmn', 'fbd', 'sfc', 'prisma', 'usecase', 'pert', or 'sequence'."
   );
 }
 function preprocess8(text2) {
@@ -18680,9 +20002,68 @@ function parse(text2, config) {
     `Diagram type '${plugin.type}' does not yet expose a parse() method.`
   );
 }
+function parseResult(text2, config) {
+  let plugin;
+  try {
+    const prepared = preprocess8(text2);
+    plugin = detectPlugin(prepared, config);
+    if (!plugin.parse) {
+      throw new Error(
+        `Diagram type '${plugin.type}' does not yet expose a parse() method.`
+      );
+    }
+    return {
+      ok: true,
+      status: "valid",
+      type: plugin.type,
+      ast: plugin.parse(prepared),
+      diagnostics: []
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: "invalid",
+      type: plugin?.type ?? config?.type ?? null,
+      diagnostics: [diagnosticFromError(err)]
+    };
+  }
+}
 function render(text2, config) {
+  if (config?.mode === "preview") return renderResult(text2, config).svg;
   const prepared = preprocess8(text2);
   const plugin = detectPlugin(prepared, config);
+  return renderWithPlugin(prepared, plugin, config);
+}
+function renderResult(text2, config) {
+  let plugin;
+  try {
+    const prepared = preprocess8(text2);
+    plugin = detectPlugin(prepared, config);
+    return {
+      ok: true,
+      status: "valid",
+      type: plugin.type,
+      svg: renderWithPlugin(prepared, plugin, config),
+      diagnostics: []
+    };
+  } catch (err) {
+    const type = plugin?.type ?? config?.type ?? null;
+    const diagnostics = [diagnosticFromError(err)];
+    return {
+      ok: false,
+      status: "invalid",
+      type,
+      svg: renderDiagnosticSvg(diagnostics, type, {
+        fontFamily: config?.fontFamily
+      }),
+      diagnostics
+    };
+  }
+}
+function renderPreview(text2, config) {
+  return renderResult(text2, config).svg;
+}
+function renderWithPlugin(prepared, plugin, config) {
   const renderConfig = {
     fontFamily: config?.fontFamily ?? "system-ui, -apple-system, sans-serif",
     fontSize: 12,
@@ -18692,6 +20073,6 @@ function render(text2, config) {
   return plugin.render(prepared, renderConfig);
 }
 
-export { decisiontree, parse, pert, pid, prisma, render, state, timeline, usecase };
-//# sourceMappingURL=chunk-GTDQAN2Z.js.map
-//# sourceMappingURL=chunk-GTDQAN2Z.js.map
+export { decisiontree, parse, parseResult, pert, pid, prisma, render, renderPreview, renderResult, state, timeline, usecase };
+//# sourceMappingURL=chunk-OK5ZS3LU.js.map
+//# sourceMappingURL=chunk-OK5ZS3LU.js.map