schematex 0.5.0 → 0.6.0

package/dist/{chunk-GTDQAN2Z.js → chunk-7AFW2J6J.js}

@@ -1,23 +1,23 @@
-import { orgchart } from './chunk-I55HO32M.js';
-import { circuit } from './chunk-HUPDIRBX.js';
+import { orgchart } from './chunk-RJMCWT7Z.js';
+import { circuit } from './chunk-UWA5MWCI.js';
 import { blockdiagram } from './chunk-EPKIJEH7.js';
-import { ladder } from './chunk-IBRW3UOA.js';
-import { sld } from './chunk-6OSUNBZY.js';
-import { entity } from './chunk-SZK376QB.js';
-import { fishbone } from './chunk-3M6T7KB4.js';
-import { venn } from './chunk-L3CTXXVZ.js';
-import { flowchart, layoutFlowchart } from './chunk-UFTYX73U.js';
-import { genogram } from './chunk-VJGMEGMR.js';
-import { ecomap } from './chunk-JHDR56XO.js';
-import { pedigree } from './chunk-ZL5RB4UV.js';
+import { ladder } from './chunk-TWLKXV2O.js';
+import { sld } from './chunk-LGABFD3L.js';
+import { entity } from './chunk-H4MT5TJP.js';
+import { fishbone } from './chunk-HAZALB7U.js';
+import { venn } from './chunk-FBS3PACU.js';
+import { flowchart, layoutFlowchart } from './chunk-7F76AWOI.js';
+import { genogram } from './chunk-DOK7LKLO.js';
+import { ecomap } from './chunk-YS6CGUNH.js';
+import { pedigree } from './chunk-N5B242WY.js';
 import { parseFrontmatter } from './chunk-2KTQ75LN.js';
-import { phylo } from './chunk-VDSYMSUY.js';
-import { sociogram } from './chunk-ZX74KJPM.js';
+import { phylo } from './chunk-MVIEIKOI.js';
+import { sociogram } from './chunk-3VB5AT4R.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 { el, escapeXml, title, desc, text, path, rect, group, svgRoot, defs, circle, polygon, line, multilineText } from './chunk-SYYBKDL7.js';
+import { logic } from './chunk-3IE7KZY4.js';
+import { resolveBaseTheme, resolveTimelineTheme, cssCustomProperties, resolvePetriTheme, resolveNetworkTheme, resolveMindmapTheme } from './chunk-LRI4RH2N.js';
+import { matchQuotedTitle, stripQuotes } from './chunk-5IKOLUWK.js';
+import { el, escapeXml, group, rect, text, line, path, circle, polygon, title, desc, svgRoot, defs, multilineText } from './chunk-SYYBKDL7.js';
 
 // src/diagrams/decisiontree/parser.ts
 var DTreeParseError = class extends Error {
@@ -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) {
@@ -5459,6 +5459,113 @@ function parseTag(tag) {
   return { letter: tag.slice(0, idx), number: tag.slice(idx + 1) };
 }
 
+// src/diagrams/pid/lint.ts
+function lintPid(text2) {
+  let ast;
+  try {
+    ast = parsePid(text2);
+  } catch {
+    return [];
+  }
+  return lintPidAst(ast);
+}
+var SIGNAL_TYPES = /* @__PURE__ */ new Set([
+  "pneumatic",
+  "electric",
+  "software",
+  "capillary",
+  "hydraulic",
+  "mechanical"
+]);
+function idLetters(tag) {
+  const head = tag.split("-")[0] ?? tag;
+  return head.replace(/[^A-Za-z]/g, "").toUpperCase();
+}
+function isController(tag) {
+  return idLetters(tag).slice(1).includes("C");
+}
+function isTransmitter(tag) {
+  return idLetters(tag).slice(1).includes("T");
+}
+function lintPidAst(ast) {
+  const out = [];
+  const instByTag = /* @__PURE__ */ new Map();
+  for (const inst of ast.instruments) instByTag.set(inst.tag, inst);
+  const controlValveIds = new Set(
+    ast.equipment.filter((e) => e.equipType === "valve_control").map((e) => e.id)
+  );
+  const signalAdj = /* @__PURE__ */ new Map();
+  const addEdge = (a, b) => {
+    if (!signalAdj.has(a)) signalAdj.set(a, /* @__PURE__ */ new Set());
+    signalAdj.get(a).add(b);
+  };
+  for (const ln of ast.lines) {
+    if (!SIGNAL_TYPES.has(ln.lineType)) continue;
+    const a = ln.from.id;
+    const b = ln.to.id;
+    if (instByTag.has(a) && instByTag.has(b)) {
+      addEdge(a, b);
+      addEdge(b, a);
+    }
+  }
+  const canReachController = (start) => {
+    const seen = /* @__PURE__ */ new Set([start]);
+    const queue = [start];
+    while (queue.length) {
+      const cur = queue.shift();
+      if (cur !== start && isController(cur)) return true;
+      for (const nxt of signalAdj.get(cur) ?? []) {
+        if (!seen.has(nxt)) {
+          seen.add(nxt);
+          queue.push(nxt);
+        }
+      }
+    }
+    return false;
+  };
+  for (const inst of ast.instruments) {
+    if (!inst.measures || isController(inst.tag)) continue;
+    if (!canReachController(inst.tag)) {
+      out.push({
+        severity: "warning",
+        code: "PID_LOOP_INCOMPLETE",
+        message: `instrument loop ${inst.tag} has no signal path to a controller`,
+        hint: `${inst.tag} measures '${inst.measures}' but no signal line (electric/pneumatic/\u2026) connects it to a controller instrument (e.g. a tag with a 'C' function letter such as FIC). Add a signal line from ${inst.tag} to the controller.`,
+        fatal: false
+      });
+    }
+  }
+  for (const ln of ast.lines) {
+    if (!SIGNAL_TYPES.has(ln.lineType)) continue;
+    const a = ln.from.id;
+    const b = ln.to.id;
+    const aInst = instByTag.get(a);
+    const bInst = instByTag.get(b);
+    const txToCtrl = aInst && isTransmitter(a) && !isController(a) && bInst && isController(b) || bInst && isTransmitter(b) && !isController(b) && aInst && isController(a);
+    if (txToCtrl && ln.lineType !== "electric") {
+      out.push({
+        severity: "warning",
+        code: "PID_SIGNAL_TYPE_MISMATCH",
+        message: `signal line ${a}\u2192${b} is '${ln.lineType}' but a transmitter\u2192controller link should be 'electric' (ISA-5.1 \xA75.2)`,
+        hint: `Set [type: electric] on this line, or rename the devices if the connection is not a transmitter\u2192controller measurement signal.`,
+        fatal: false
+      });
+      continue;
+    }
+    const ctrlToValve = aInst && isController(a) && controlValveIds.has(b) || bInst && isController(b) && controlValveIds.has(a);
+    if (ctrlToValve && ln.lineType !== "pneumatic") {
+      out.push({
+        severity: "warning",
+        code: "PID_SIGNAL_TYPE_MISMATCH",
+        message: `signal line ${a}\u2192${b} is '${ln.lineType}' but a controller\u2192control-valve link should be 'pneumatic' (ISA-5.1 \xA75.2)`,
+        hint: `Set [type: pneumatic] on this line, or use [type: electric] only if the valve has an electric actuator.`,
+        fatal: false
+      });
+    }
+  }
+  return out;
+}
+
 // src/diagrams/pid/index.ts
 var pid = {
   type: "pid",
@@ -5466,6 +5573,7 @@ var pid = {
     return /^\s*pid\b/i.test(text2);
   },
   parse: parsePid,
+  lint: lintPid,
   render(text2, config) {
     const ast = parsePid(text2);
     return renderPidAST(ast);
@@ -6510,7 +6618,7 @@ function layoutPrisma(ast) {
     lines: incResized.wrappedLines
   });
   cursorY = incY + incResized.height + PRISMA_CONST.OUTER_PAD_BOTTOM;
-  const arrow = (x1, y1, x2, y2) => `M ${x1} ${y1} L ${x2} ${y2}`;
+  const arrow2 = (x1, y1, x2, y2) => `M ${x1} ${y1} L ${x2} ${y2}`;
   const mainColRight = mainColLeft + mainW;
   const rightColArrowEnd = rightColLeft - PRISMA_CONST.ARROWHEAD_LEN;
   if (idRemovedSpec) {
@@ -6519,7 +6627,7 @@ function layoutPrisma(ast) {
       kind: "exclusion",
       from: "id-databases",
       to: "id-removed",
-      d: arrow(mainColRight, ay, rightColArrowEnd, ay)
+      d: arrow2(mainColRight, ay, rightColArrowEnd, ay)
     });
   }
   if (dual && idRightSpec) {
@@ -6528,7 +6636,7 @@ function layoutPrisma(ast) {
       kind: "merge-trunk",
       from: "id-databases",
       to: "screening",
-      d: arrow(mainColCenterX, idRowY + idDbBox.height, mainColCenterX, screeningY - PRISMA_CONST.ARROWHEAD_LEN)
+      d: arrow2(mainColCenterX, idRowY + idDbBox.height, mainColCenterX, screeningY - PRISMA_CONST.ARROWHEAD_LEN)
     });
     edges.push({
       kind: "merge-leg",
@@ -6541,7 +6649,7 @@ function layoutPrisma(ast) {
       kind: "main",
       from: "id-databases",
       to: "screening",
-      d: arrow(mainColCenterX, idRowY + idDbBox.height, mainColCenterX, screeningY - PRISMA_CONST.ARROWHEAD_LEN)
+      d: arrow2(mainColCenterX, idRowY + idDbBox.height, mainColCenterX, screeningY - PRISMA_CONST.ARROWHEAD_LEN)
     });
   }
   if (previousBoxBottom >= 0) {
@@ -6549,34 +6657,34 @@ function layoutPrisma(ast) {
       kind: "previous",
       from: "previous",
       to: "id-databases",
-      d: arrow(previousBoxCenterX, previousBoxBottom, mainColCenterX, headerRowY - PRISMA_CONST.ARROWHEAD_LEN)
+      d: arrow2(previousBoxCenterX, previousBoxBottom, mainColCenterX, headerRowY - PRISMA_CONST.ARROWHEAD_LEN)
     });
   }
   edges.push({
     kind: "main",
     from: "screening",
     to: "eligibility",
-    d: arrow(mainColCenterX, screeningY + screeningResized.height, mainColCenterX, eligY - PRISMA_CONST.ARROWHEAD_LEN)
+    d: arrow2(mainColCenterX, screeningY + screeningResized.height, mainColCenterX, eligY - PRISMA_CONST.ARROWHEAD_LEN)
   });
   edges.push({
     kind: "main",
     from: "eligibility",
     to: "included",
-    d: arrow(mainColCenterX, eligY + eligResized.height, mainColCenterX, incY - PRISMA_CONST.ARROWHEAD_LEN)
+    d: arrow2(mainColCenterX, eligY + eligResized.height, mainColCenterX, incY - PRISMA_CONST.ARROWHEAD_LEN)
   });
   const screeningArrowY = screeningY + screeningResized.height / 2;
   edges.push({
     kind: "exclusion",
     from: "screening",
     to: "screening-excluded",
-    d: arrow(mainColRight, screeningArrowY, rightColArrowEnd, screeningArrowY)
+    d: arrow2(mainColRight, screeningArrowY, rightColArrowEnd, screeningArrowY)
   });
   const eligArrowY = eligY + eligResized.height / 2;
   edges.push({
     kind: "exclusion",
     from: "eligibility",
     to: "eligibility-excluded",
-    d: arrow(mainColRight, eligArrowY, rightColArrowEnd, eligArrowY)
+    d: arrow2(mainColRight, eligArrowY, rightColArrowEnd, eligArrowY)
   });
   let pageHeight = cursorY;
   if (warnings.length > 0) {
@@ -7184,7 +7292,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 +7310,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 +7347,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 +7383,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 +8138,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 +8627,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 +8645,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 +8774,23 @@ function parseTaskLine(ln, ast) {
     milestone = true;
     return "";
   }).trim();
-  const markers3 = [];
+  const markers5 = [];
   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 });
+    markers5.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 < markers5.length; i++) {
+    const cur = markers5[i];
+    const nextStart = i + 1 < markers5.length ? markers5[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 = (markers5.length ? rest.slice(0, markers5[0].start) : rest).trim();
   if (preamble) {
     throw new PertParseError(`unexpected text '${preamble}' in task '${id}'`, ln.line);
   }
@@ -8710,7 +8818,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,
@@ -10085,186 +10193,3832 @@ function renderLanes(lanes, width) {
       text({ class: "sx-pert-lane-label", x: 16, y: ln.y + ln.height / 2 + 4, "text-anchor": "start" }, ln.name)
     );
   }
-  return group({ class: "sx-pert-lane" }, parts);
+  return group({ class: "sx-pert-lane" }, parts);
+}
+function renderSentinel(s) {
+  return group({ class: "sx-pert-sentinel", "data-id": s.id }, [
+    circle({ cx: s.cx, cy: s.cy, r: s.r }),
+    text({ x: s.cx, y: s.cy + 3.5, "text-anchor": "middle" }, s.label)
+  ]);
+}
+function renderAxis2(axis, gridTop) {
+  const parts = [];
+  for (const tk of axis.ticks) {
+    if (tk.major) {
+      parts.push(line({ class: "sx-pert-grid", x1: tk.pos, y1: gridTop, x2: tk.pos, y2: axis.baseline }));
+    }
+  }
+  parts.push(line({ class: "baseline", x1: axis.start, y1: axis.baseline, x2: axis.end, y2: axis.baseline }));
+  for (const tk of axis.ticks) {
+    const len = tk.major ? 7 : 4;
+    parts.push(line({ x1: tk.pos, y1: axis.baseline, x2: tk.pos, y2: axis.baseline + len }));
+    if (tk.major) {
+      parts.push(
+        text({ x: tk.pos, y: axis.baseline + 18, "text-anchor": "middle" }, fmtVal(tk.value))
+      );
+    }
+  }
+  return group({ class: "sx-pert-axis" }, parts);
+}
+function renderAoa(aoa) {
+  const arcEls = [];
+  const labelEls = [];
+  for (const a of aoa.arcs) {
+    const cls = `sx-pert-aoa-arc${a.dummy ? " dummy" : ""}${a.critical ? " critical" : ""}`;
+    const marker = a.critical ? "url(#sx-pert-arrow-crit)" : "url(#sx-pert-arrow)";
+    arcEls.push(
+      path({
+        class: cls,
+        d: a.d,
+        "marker-end": marker,
+        "data-from": a.from,
+        "data-to": a.to,
+        "data-task": a.taskId ?? "",
+        "data-dummy": String(a.dummy),
+        "data-critical": String(a.critical)
+      })
+    );
+    if (!a.dummy && a.label) {
+      const critCls = a.critical ? " critical" : "";
+      const durStr = fmtVal(a.duration ?? 0);
+      const w = Math.max(a.label.length * 6.2, durStr.length * 6) + 8;
+      labelEls.push(
+        rect({ class: "sx-pert-edge-halo", x: a.labelX - w / 2, y: a.labelY - 16, width: w, height: 31, rx: 3, ry: 3 })
+      );
+      labelEls.push(
+        text({ class: `sx-pert-aoa-name${critCls}`, x: a.labelX, y: a.labelY - 4, "text-anchor": "middle" }, a.label)
+      );
+      labelEls.push(
+        text({ class: `sx-pert-aoa-dur${critCls}`, x: a.labelX, y: a.labelY + 12, "text-anchor": "middle" }, durStr)
+      );
+    }
+  }
+  const eventEls = [];
+  for (const e of aoa.events) {
+    eventEls.push(
+      group({ class: `sx-pert-aoa-event${e.critical ? " critical" : ""}`, "data-event": e.id }, [
+        circle({ cx: e.x, cy: e.y, r: e.r }),
+        text({ x: e.x, y: e.y + 4.5, "text-anchor": "middle" }, String(e.id))
+      ])
+    );
+  }
+  return group({ class: "sx-pert-aoa" }, [
+    group({ class: "sx-pert-aoa-arcs" }, arcEls),
+    group({ class: "sx-pert-aoa-labels" }, labelEls),
+    group({ class: "sx-pert-aoa-events" }, eventEls)
+  ]);
+}
+function summaryText(summary) {
+  const u = unitWord(summary.unit);
+  const dur = `${fmtVal(summary.projectDuration)}${u ? " " + u : ""}`;
+  const sigma = summary.projectStdDev !== void 0 ? ` \xB7 \u03C3 \u2248 ${fmtVal(summary.projectStdDev)}` : "";
+  const plain = `Project duration ${dur} \xB7 ${summary.taskCount} tasks \xB7 ${summary.depCount} dependencies \xB7 ${summary.criticalCount} critical${sigma}`;
+  const critPath = summary.criticalPath.map((id) => id).join(" \u2192 ");
+  return { plain, critPath };
+}
+function renderPertLayout(layout, config) {
+  const t = resolveBaseTheme(config?.theme ?? "default");
+  const children = [];
+  const cp = layout.summary.criticalPath;
+  children.push(title(`PERT network${layout.title ? " \u2014 " + layout.title : ""}`));
+  children.push(
+    desc(
+      `${layout.summary.taskCount} activities, project duration ${fmtVal(layout.summary.projectDuration)} ${unitWord(layout.unit)}` + (cp.length ? `, critical path ${cp.join(" \u2192 ")}` : "") + "."
+    )
+  );
+  children.push(el("style", {}, buildCss4(t)));
+  children.push(markers2());
+  if (layout.title) {
+    children.push(
+      text({ x: layout.width / 2, y: 26, class: "sx-pert-title", "text-anchor": "middle" }, layout.title)
+    );
+  }
+  if (layout.aoa) {
+    children.push(renderAoa(layout.aoa));
+  } else {
+    if (layout.lanes && layout.lanes.length) {
+      children.push(renderLanes(layout.lanes, layout.width));
+    }
+    if (layout.axis) {
+      let minBoxY = Infinity;
+      for (const b of layout.boxes) minBoxY = Math.min(minBoxY, b.y);
+      children.push(renderAxis2(layout.axis, isFinite(minBoxY) ? minBoxY : layout.axis.baseline - 20));
+    }
+    const edgeEls = [];
+    for (const e of layout.edges) edgeEls.push(renderEdge3(e));
+    children.push(group({ class: "sx-pert-edges" }, edgeEls));
+    if (layout.sentinels.length) {
+      children.push(group({ class: "sx-pert-sentinels" }, layout.sentinels.map(renderSentinel)));
+    }
+    const boxEls = [];
+    for (const b of layout.boxes) boxEls.push(renderBox2(b, layout.mode));
+    children.push(group({ class: "sx-pert-tasks" }, boxEls));
+    const labelEls = [];
+    for (const e of layout.edges) {
+      const lbl = renderEdgeLabel2(e);
+      if (lbl) labelEls.push(lbl);
+    }
+    children.push(group({ class: "sx-pert-labels" }, labelEls));
+  }
+  const { plain, critPath } = summaryText(layout.summary);
+  const footerY = layout.height - 12;
+  const footerParts = [
+    text({ class: "sx-pert-summary", x: PERT_PAD, y: footerY, "text-anchor": "start" }, plain)
+  ];
+  if (critPath) {
+    footerParts.push(
+      text(
+        { class: "sx-pert-summary crit", x: layout.width - PERT_PAD, y: footerY, "text-anchor": "end" },
+        `Critical path: ${critPath}`
+      )
+    );
+  }
+  children.push(group({ class: "sx-pert-footer" }, footerParts));
+  return svgRoot(
+    {
+      class: "sx-pert",
+      role: "img",
+      "aria-label": escapeXml(layout.title ?? "PERT network diagram"),
+      width: layout.width,
+      height: layout.height,
+      viewBox: `0 0 ${layout.width} ${layout.height}`,
+      "data-diagram-type": "pert"
+    },
+    children
+  );
+}
+var PERT_PAD = 24;
+function renderPert(textOrAst, config) {
+  const ast = typeof textOrAst === "string" ? parsePert(textOrAst) : textOrAst;
+  const schedule = schedulePert(ast);
+  const layout = layoutPert(ast, schedule);
+  return renderPertLayout(layout, config);
+}
+
+// src/diagrams/pert/index.ts
+var pert = {
+  type: "pert",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^pert\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parsePert,
+  render(text2, config) {
+    return renderPert(text2, config);
+  }
+};
+
+// 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 arrow2 = arrowKind(token);
+    let create = false;
+    if (right.startsWith("*")) {
+      create = true;
+      right = right.slice(1).trim();
+    }
+    const from = arrow2 === "found" ? "" : stripQuotes(left);
+    const to = arrow2 === "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: arrow2,
+      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 buildCss5(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_W = 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_W + 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", {}, buildCss5(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/diagrams/petri/parser.ts
+var PetriParseError = class extends Error {
+  line;
+  constructor(message, line2) {
+    super(line2 !== void 0 ? `${message} (line ${line2})` : message);
+    this.name = "PetriParseError";
+    this.line = line2;
+  }
+};
+var OPENERS = ['"', "\u201C", "\u300C", "\u300E", "\xAB"];
+var CLOSERS = ['"', "\u201D", "\u300D", "\u300F", "\xBB"];
+function tokenize3(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === " " || c === "	") {
+      i++;
+      continue;
+    }
+    const oi = OPENERS.indexOf(c);
+    if (oi >= 0) {
+      const close = CLOSERS[oi];
+      let j2 = i + 1;
+      let buf2 = "";
+      while (j2 < s.length && s[j2] !== close && s[j2] !== '"') {
+        buf2 += s[j2];
+        j2++;
+      }
+      out.push({ text: buf2, quoted: true });
+      i = j2 + 1;
+      continue;
+    }
+    let j = i;
+    let buf = "";
+    while (j < s.length && s[j] !== " " && s[j] !== "	") {
+      buf += s[j];
+      j++;
+    }
+    out.push({ text: buf, quoted: false });
+    i = j;
+  }
+  return out;
+}
+function normalizeKeyNums(line2) {
+  return line2.replace(/([A-Za-z]+)\s*:\s*(-?\d+(?:\.\d+)?)/g, "$1:$2");
+}
+var DOT_RE = /^[•●･]+$/;
+var ARC_RE = /^(\S+?)\s*(->|-o|=>|--)\s*(\S+)(.*)$/;
+function toInt(raw, what, line2) {
+  if (!/^-?\d+$/.test(raw)) {
+    throw new PetriParseError(`${what} must be an integer, got "${raw}"`, line2);
+  }
+  return parseInt(raw, 10);
+}
+function parsePetri(text2) {
+  const rawLines = text2.split(/\r?\n/);
+  const ast = {
+    type: "petri",
+    direction: "lr",
+    tokenStyle: "auto",
+    places: [],
+    transitions: [],
+    arcs: [],
+    fireSequence: [],
+    warnings: []
+  };
+  const placeIds = /* @__PURE__ */ new Set();
+  const transIds = /* @__PURE__ */ new Set();
+  let sawHeader = false;
+  for (let ln = 0; ln < rawLines.length; ln++) {
+    const rawLine = rawLines[ln];
+    const lineNo = ln + 1;
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith("//")) continue;
+    if (!sawHeader && /^petri(net)?\b/i.test(trimmed)) {
+      sawHeader = true;
+      const toks = tokenize3(trimmed);
+      const titleTok = toks.find((t, idx) => idx > 0 && t.quoted);
+      if (titleTok) ast.title = titleTok.text;
+      else if (toks[1] && !toks[1].quoted) ast.title = toks.slice(1).map((t) => t.text).join(" ");
+      continue;
+    }
+    if (!sawHeader) {
+      if (/^petri(net)?\b/i.test(trimmed)) {
+        sawHeader = true;
+        continue;
+      }
+    }
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith("layout:")) {
+      const v = trimmed.slice(trimmed.indexOf(":") + 1).trim().toLowerCase();
+      if (v === "lr" || v === "tb") ast.direction = v;
+      else ast.warnings.push(`Unknown layout "${v}" (line ${lineNo}); using lr.`);
+      continue;
+    }
+    if (lower.startsWith("tokens:")) {
+      const v = trimmed.slice(trimmed.indexOf(":") + 1).trim().toLowerCase();
+      if (v === "dots" || v === "count" || v === "auto") ast.tokenStyle = v;
+      else ast.warnings.push(`Unknown token style "${v}" (line ${lineNo}); using auto.`);
+      continue;
+    }
+    if (lower.startsWith("marking:")) {
+      parseMarking(trimmed.slice(trimmed.indexOf(":") + 1), lineNo, ast, placeIds);
+      continue;
+    }
+    if (lower.startsWith("fire:")) {
+      const ids = trimmed.slice(trimmed.indexOf(":") + 1).split(",").map((s) => s.trim()).filter(Boolean);
+      ast.fireSequence.push(...ids);
+      continue;
+    }
+    if (/^place\b/i.test(trimmed)) {
+      ast.places.push(parsePlace(trimmed, lineNo, placeIds, transIds));
+      continue;
+    }
+    if (/^transition\b/i.test(trimmed)) {
+      ast.transitions.push(parseTransition(rawLine.trim(), lineNo, placeIds, transIds));
+      continue;
+    }
+    const arcM = ARC_RE.exec(trimmed);
+    if (arcM) {
+      ast.arcs.push(parseArc(arcM, lineNo, placeIds, transIds));
+      continue;
+    }
+    ast.warnings.push(`Unrecognized line ${lineNo}: "${trimmed}"`);
+  }
+  for (const id of ast.fireSequence) {
+    if (!transIds.has(id)) {
+      throw new PetriParseError(`fire: references unknown transition "${id}"`);
+    }
+  }
+  return ast;
+}
+function declareDup(id, lineNo, placeIds, transIds) {
+  if (placeIds.has(id) || transIds.has(id)) {
+    throw new PetriParseError(`duplicate node id "${id}"`, lineNo);
+  }
+}
+function parsePlace(line2, lineNo, placeIds, transIds) {
+  const toks = tokenize3(normalizeKeyNums(line2));
+  const idTok = toks[1];
+  if (!idTok || idTok.quoted) throw new PetriParseError(`place is missing an id`, lineNo);
+  const id = idTok.text;
+  declareDup(id, lineNo, placeIds, transIds);
+  const place = { id, tokens: 0, line: lineNo };
+  const labelParts = [];
+  for (let i = 2; i < toks.length; i++) {
+    const t = toks[i];
+    if (t.quoted) {
+      labelParts.push(t.text);
+      continue;
+    }
+    const txt = t.text;
+    if (/^\*\d+$/.test(txt)) {
+      place.tokens = parseInt(txt.slice(1), 10);
+    } else if (DOT_RE.test(txt)) {
+      place.tokens = [...txt].length;
+    } else if (/^tokens:/i.test(txt)) {
+      place.tokens = toInt(txt.slice(txt.indexOf(":") + 1), "tokens", lineNo);
+    } else if (/^capacity:/i.test(txt)) {
+      const k = toInt(txt.slice(txt.indexOf(":") + 1), "capacity", lineNo);
+      if (k <= 0) throw new PetriParseError(`capacity must be a positive integer`, lineNo);
+      place.capacity = k;
+    } else {
+      labelParts.push(txt);
+    }
+  }
+  if (place.tokens < 0) throw new PetriParseError(`token count cannot be negative`, lineNo);
+  if (labelParts.length) place.label = labelParts.join(" ");
+  placeIds.add(id);
+  return place;
+}
+function parseTransition(line2, lineNo, placeIds, transIds) {
+  let guard;
+  const stripped = line2.replace(/\[([^\]]*)\]/, (_m, g) => {
+    guard = String(g).trim();
+    return " ";
+  });
+  const toks = tokenize3(normalizeKeyNums(stripped));
+  const idTok = toks[1];
+  if (!idTok || idTok.quoted) throw new PetriParseError(`transition is missing an id`, lineNo);
+  const id = idTok.text;
+  declareDup(id, lineNo, placeIds, transIds);
+  const tr = { id, kind: "immediate", line: lineNo };
+  if (guard) tr.guard = guard;
+  const labelParts = [];
+  for (let i = 2; i < toks.length; i++) {
+    const t = toks[i];
+    if (t.quoted) {
+      labelParts.push(t.text);
+      continue;
+    }
+    const txt = t.text;
+    const low = txt.toLowerCase();
+    if (low === "immediate") tr.kind = "immediate";
+    else if (low === "timed") tr.kind = "timed";
+    else if (/^rate:/i.test(txt)) {
+      tr.rate = parseFloat(txt.slice(txt.indexOf(":") + 1));
+      tr.kind = "timed";
+    } else if (/^(prio|priority):/i.test(txt)) {
+      tr.priority = toInt(txt.slice(txt.indexOf(":") + 1), "priority", lineNo);
+    } else {
+      labelParts.push(txt);
+    }
+  }
+  if (labelParts.length) tr.label = labelParts.join(" ");
+  transIds.add(id);
+  return tr;
+}
+var ARROW_TYPE = {
+  "->": "standard",
+  "-o": "inhibitor",
+  "--": "read",
+  "=>": "reset"
+};
+function parseArc(m, lineNo, placeIds, transIds) {
+  const from = m[1];
+  const arrow2 = m[2];
+  const to = m[3];
+  const rest = m[4] ?? "";
+  const type = ARROW_TYPE[arrow2];
+  const known = (id) => placeIds.has(id) ? "place" : transIds.has(id) ? "transition" : null;
+  const kf = known(from);
+  const kt = known(to);
+  if (!kf) throw new PetriParseError(`arc references unknown node "${from}" \u2014 declare it as a place or transition first`, lineNo);
+  if (!kt) throw new PetriParseError(`arc references unknown node "${to}" \u2014 declare it as a place or transition first`, lineNo);
+  if (kf === kt) {
+    throw new PetriParseError(
+      `arc connects two ${kf}s \u2014 a Petri net arc must go place\u2192transition or transition\u2192place`,
+      lineNo
+    );
+  }
+  if ((type === "inhibitor" || type === "reset") && kf !== "place") {
+    throw new PetriParseError(`${type} arcs are place\u2192transition only`, lineNo);
+  }
+  const arc = { from, to, type, weight: 1, line: lineNo };
+  const toks = tokenize3(normalizeKeyNums(rest));
+  const labelParts = [];
+  for (const t of toks) {
+    if (t.quoted) {
+      labelParts.push(t.text);
+      continue;
+    }
+    const txt = t.text;
+    if (/^\*\d+$/.test(txt)) arc.weight = parseInt(txt.slice(1), 10);
+    else if (/^weight:/i.test(txt)) arc.weight = toInt(txt.slice(txt.indexOf(":") + 1), "weight", lineNo);
+    else labelParts.push(txt);
+  }
+  if (arc.weight <= 0) throw new PetriParseError(`arc weight must be a positive integer`, lineNo);
+  if (labelParts.length) arc.label = labelParts.join(" ");
+  return arc;
+}
+function parseMarking(body, lineNo, ast, placeIds) {
+  for (const part of body.split(",")) {
+    const p = part.trim();
+    if (!p) continue;
+    const eq = p.indexOf("=");
+    if (eq < 0) {
+      ast.warnings.push(`Bad marking entry "${p}" (line ${lineNo}); expected id=n.`);
+      continue;
+    }
+    const id = p.slice(0, eq).trim();
+    const n = toInt(p.slice(eq + 1).trim(), "marking", lineNo);
+    if (!placeIds.has(id)) {
+      throw new PetriParseError(`marking references unknown place "${id}"`, lineNo);
+    }
+    const place = ast.places.find((pl) => pl.id === id);
+    if (place) place.tokens = n;
+  }
+}
+
+// src/diagrams/petri/layout.ts
+var PETRI_CONST = {
+  PLACE_R: 18,
+  TRANS_BAR_W: 8,
+  TRANS_BAR_H: 44,
+  TRANS_BOX_W: 26,
+  TRANS_BOX_H: 40,
+  LAYER_GAP: 70,
+  RANK_GAP: 46,
+  TOKEN_R: 3.5,
+  TOKEN_COUNT_MAX_DOTS: 4,
+  ARC_WEIGHT_OFFSET: 9,
+  LABEL_GAP: 6,
+  MARGIN: 22,
+  BACKEDGE_BOW: 30,
+  LABEL_LINE_H: 13,
+  CHAR_W: 6.2
+};
+function layoutPetri(ast) {
+  const C2 = PETRI_CONST;
+  const dir = ast.direction;
+  const warnings = [...ast.warnings];
+  const kindOf = /* @__PURE__ */ new Map();
+  for (const p of ast.places) kindOf.set(p.id, "place");
+  for (const t of ast.transitions) kindOf.set(t.id, "transition");
+  const ids = [...ast.places.map((p) => p.id), ...ast.transitions.map((t) => t.id)];
+  const declOrder = /* @__PURE__ */ new Map();
+  ids.forEach((id, i) => declOrder.set(id, i));
+  const edges = ast.arcs.map((a) => ({ from: a.from, to: a.to, reversed: false }));
+  const adj = /* @__PURE__ */ new Map();
+  ids.forEach((id) => adj.set(id, []));
+  edges.forEach((e, i) => adj.get(e.from).push(i));
+  const state2 = /* @__PURE__ */ new Map();
+  ids.forEach((id) => state2.set(id, 0));
+  const dfs = (u) => {
+    state2.set(u, 1);
+    for (const ei of adj.get(u)) {
+      const e = edges[ei];
+      const s = state2.get(e.to);
+      if (s === 1) e.reversed = true;
+      else if (s === 0) dfs(e.to);
+    }
+    state2.set(u, 2);
+  };
+  for (const id of ids) if (state2.get(id) === 0) dfs(id);
+  const succ = /* @__PURE__ */ new Map();
+  const indeg = /* @__PURE__ */ new Map();
+  ids.forEach((id) => {
+    succ.set(id, []);
+    indeg.set(id, 0);
+  });
+  for (const e of edges) {
+    const [from, to] = e.reversed ? [e.to, e.from] : [e.from, e.to];
+    succ.get(from).push(to);
+    indeg.set(to, indeg.get(to) + 1);
+  }
+  const layer = /* @__PURE__ */ new Map();
+  ids.forEach((id) => layer.set(id, 0));
+  const queue = ids.filter((id) => indeg.get(id) === 0);
+  const indegWork = new Map(indeg);
+  let qi = 0;
+  const q = [...queue];
+  while (qi < q.length) {
+    const u = q[qi++];
+    for (const v of succ.get(u)) {
+      layer.set(v, Math.max(layer.get(v), layer.get(u) + 1));
+      indegWork.set(v, indegWork.get(v) - 1);
+      if (indegWork.get(v) === 0) q.push(v);
+    }
+  }
+  const maxLayer = Math.max(0, ...ids.map((id) => layer.get(id)));
+  const layers = Array.from({ length: maxLayer + 1 }, () => []);
+  for (const id of ids) layers[layer.get(id)].push(id);
+  layers.forEach((arr) => arr.sort((a, b) => declOrder.get(a) - declOrder.get(b)));
+  const pos = /* @__PURE__ */ new Map();
+  const reindex = () => layers.forEach((arr) => arr.forEach((id, i) => pos.set(id, i)));
+  reindex();
+  const preds = /* @__PURE__ */ new Map();
+  const sucs = /* @__PURE__ */ new Map();
+  ids.forEach((id) => {
+    preds.set(id, []);
+    sucs.set(id, []);
+  });
+  for (const e of edges) {
+    const [from, to] = e.reversed ? [e.to, e.from] : [e.from, e.to];
+    sucs.get(from).push(to);
+    preds.get(to).push(from);
+  }
+  const bary = (id, neigh) => {
+    const ns = neigh.get(id);
+    if (!ns.length) return pos.get(id);
+    return ns.reduce((s, n) => s + pos.get(n), 0) / ns.length;
+  };
+  for (let sweep = 0; sweep < 4; sweep++) {
+    const downward = sweep % 2 === 0;
+    const range = downward ? [...Array(layers.length).keys()].slice(1) : [...Array(layers.length).keys()].slice(0, -1).reverse();
+    for (const L of range) {
+      const neigh = downward ? preds : sucs;
+      layers[L].sort((a, b) => bary(a, neigh) - bary(b, neigh) || declOrder.get(a) - declOrder.get(b));
+      reindex();
+    }
+  }
+  const sizeOf2 = (id) => {
+    if (kindOf.get(id) === "place") return { halfW: C2.PLACE_R, halfH: C2.PLACE_R, r: C2.PLACE_R };
+    const tr = ast.transitions.find((t) => t.id === id);
+    const long = tr.kind === "timed" ? C2.TRANS_BOX_H : C2.TRANS_BAR_H;
+    const thin = tr.kind === "timed" ? C2.TRANS_BOX_W : C2.TRANS_BAR_W;
+    const halfW = dir === "lr" ? thin / 2 : long / 2;
+    const halfH = dir === "lr" ? long / 2 : thin / 2;
+    return { halfW, halfH, r: 0 };
+  };
+  const flowHalf = (id) => {
+    const s = sizeOf2(id);
+    return dir === "lr" ? s.halfW : s.halfH;
+  };
+  const crossHalf = (id) => {
+    const s = sizeOf2(id);
+    return dir === "lr" ? s.halfH : s.halfW;
+  };
+  const layerHalf = layers.map((arr) => Math.max(0, ...arr.map(flowHalf)));
+  const slot = Math.max(0, ...ids.map(crossHalf)) * 2 + C2.RANK_GAP;
+  const maxCount = Math.max(1, ...layers.map((a) => a.length));
+  const crossCenter = C2.MARGIN + C2.LABEL_LINE_H * 2 + maxCount * slot / 2;
+  const flowCenter = [];
+  let acc = C2.MARGIN + C2.LABEL_LINE_H * 2;
+  for (let L = 0; L < layers.length; L++) {
+    acc += layerHalf[L];
+    flowCenter[L] = acc;
+    acc += layerHalf[L] + C2.LAYER_GAP;
+  }
+  const geom = /* @__PURE__ */ new Map();
+  layers.forEach((arr, L) => {
+    const n = arr.length;
+    const total = (n - 1) * slot;
+    arr.forEach((id, i) => {
+      const cross = crossCenter - total / 2 + i * slot;
+      const flow = flowCenter[L];
+      const cx = dir === "lr" ? flow : cross;
+      const cy = dir === "lr" ? cross : flow;
+      const s = sizeOf2(id);
+      geom.set(id, { id, kind: kindOf.get(id), cx, cy, halfW: s.halfW, halfH: s.halfH, r: s.r, layer: L });
+    });
+  });
+  const marking = /* @__PURE__ */ new Map();
+  for (const p of ast.places) marking.set(p.id, p.tokens);
+  const inArcs = (tid) => ast.arcs.filter((a) => a.to === tid);
+  const outArcs = (tid) => ast.arcs.filter((a) => a.from === tid);
+  const capOf = (pid2) => ast.places.find((p) => p.id === pid2)?.capacity;
+  const isEnabled = (tid, M) => {
+    for (const a of inArcs(tid)) {
+      const have = M.get(a.from) ?? 0;
+      if (a.type === "standard" || a.type === "read") {
+        if (have < a.weight) return false;
+      } else if (a.type === "inhibitor") {
+        if (have >= a.weight) return false;
+      }
+    }
+    for (const a of outArcs(tid)) {
+      const cap = capOf(a.to);
+      if (cap !== void 0 && (M.get(a.to) ?? 0) + a.weight > cap) return false;
+    }
+    return true;
+  };
+  const applyFire = (tid, M) => {
+    for (const a of inArcs(tid)) {
+      if (a.type === "standard") M.set(a.from, (M.get(a.from) ?? 0) - a.weight);
+      else if (a.type === "reset") M.set(a.from, 0);
+    }
+    for (const a of outArcs(tid)) M.set(a.to, (M.get(a.to) ?? 0) + a.weight);
+  };
+  ast.fireSequence.forEach((tid, i) => {
+    if (isEnabled(tid, marking)) applyFire(tid, marking);
+    else warnings.push(`fire step ${i + 1}: transition "${tid}" is not enabled in the current marking; skipped.`);
+  });
+  const producers = (pid2) => ast.arcs.filter((a) => a.to === pid2 && a.type === "standard").length;
+  const enabledIds = [];
+  const deadIds = /* @__PURE__ */ new Set();
+  for (const tr of ast.transitions) {
+    if (isEnabled(tr.id, marking)) {
+      enabledIds.push(tr.id);
+      continue;
+    }
+    const dead = inArcs(tr.id).some(
+      (a) => (a.type === "standard" || a.type === "read") && (marking.get(a.from) ?? 0) < a.weight && producers(a.from) === 0
+    );
+    if (dead) deadIds.add(tr.id);
+  }
+  const boundary = (g, dx2, dy2) => {
+    const len = Math.hypot(dx2, dy2) || 1;
+    const ux = dx2 / len;
+    const uy = dy2 / len;
+    if (g.kind === "place") return { x: g.cx + ux * g.r, y: g.cy + uy * g.r };
+    const tx = ux !== 0 ? g.halfW / Math.abs(ux) : Infinity;
+    const ty = uy !== 0 ? g.halfH / Math.abs(uy) : Infinity;
+    const t = Math.min(tx, ty);
+    return { x: g.cx + ux * t, y: g.cy + uy * t };
+  };
+  const bandMaxCross = Math.max(...[...geom.values()].map((g) => dir === "lr" ? g.cy + g.halfH : g.cx + g.halfW));
+  const arcGeoms = ast.arcs.map((a, i) => {
+    const A = geom.get(a.from);
+    const B = geom.get(a.to);
+    const reversed = edges[i].reversed;
+    let points;
+    if (!reversed) {
+      const pA = boundary(A, B.cx - A.cx, B.cy - A.cy);
+      const pB = boundary(B, A.cx - B.cx, A.cy - B.cy);
+      points = [pA, pB];
+    } else {
+      if (dir === "lr") {
+        const pA = boundary(A, 0, 1);
+        const pB = boundary(B, 0, 1);
+        const bowY = bandMaxCross + C2.BACKEDGE_BOW;
+        points = [pA, { x: pA.x, y: bowY }, { x: pB.x, y: bowY }, pB];
+      } else {
+        const pA = boundary(A, 1, 0);
+        const pB = boundary(B, 1, 0);
+        const bowX = bandMaxCross + C2.BACKEDGE_BOW;
+        points = [pA, { x: bowX, y: pA.y }, { x: bowX, y: pB.y }, pB];
+      }
+    }
+    const p0 = points[0];
+    const p1 = points[points.length - 1];
+    const mx = (p0.x + p1.x) / 2;
+    const my = (p0.y + p1.y) / 2;
+    const ddx = p1.x - p0.x;
+    const ddy = p1.y - p0.y;
+    const dl = Math.hypot(ddx, ddy) || 1;
+    const labelX = mx - ddy / dl * C2.ARC_WEIGHT_OFFSET;
+    const labelY = my + ddx / dl * C2.ARC_WEIGHT_OFFSET;
+    return { arc: a, type: a.type, weight: a.weight, points, reversed, labelX, labelY };
+  });
+  const hasIncoming = (pid2) => ast.arcs.some((a) => a.to === pid2);
+  const hasOutgoing = (pid2) => ast.arcs.some((a) => a.from === pid2);
+  const placeBoxes = ast.places.map((p) => {
+    const g = geom.get(p.id);
+    return {
+      place: p,
+      cx: g.cx,
+      cy: g.cy,
+      r: g.r,
+      tokens: marking.get(p.id) ?? 0,
+      isSource: !hasIncoming(p.id),
+      isSink: !hasOutgoing(p.id)
+    };
+  });
+  const transBoxes = ast.transitions.map((t) => {
+    const g = geom.get(t.id);
+    return {
+      transition: t,
+      cx: g.cx,
+      cy: g.cy,
+      w: g.halfW * 2,
+      h: g.halfH * 2,
+      enabled: enabledIds.includes(t.id),
+      dead: deadIds.has(t.id)
+    };
+  });
+  const bb = { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity };
+  const addBox = (x0, y0, x1, y1) => {
+    bb.minX = Math.min(bb.minX, x0, x1);
+    bb.minY = Math.min(bb.minY, y0, y1);
+    bb.maxX = Math.max(bb.maxX, x0, x1);
+    bb.maxY = Math.max(bb.maxY, y0, y1);
+  };
+  const addPt = (p) => addBox(p.x, p.y, p.x, p.y);
+  const labelW = (s) => s ? s.length * C2.CHAR_W : 0;
+  for (const pb of placeBoxes) {
+    addBox(pb.cx - pb.r, pb.cy - pb.r, pb.cx + pb.r, pb.cy + pb.r);
+    const lw = Math.max(labelW(pb.place.id), labelW(pb.place.label)) / 2;
+    addBox(pb.cx - lw, pb.cy - pb.r - C2.LABEL_LINE_H * 2, pb.cx + lw, pb.cy);
+    if (pb.place.capacity !== void 0) addBox(pb.cx, pb.cy + pb.r, pb.cx + 24, pb.cy + pb.r + C2.LABEL_LINE_H);
+  }
+  for (const tb of transBoxes) {
+    addBox(tb.cx - tb.w / 2, tb.cy - tb.h / 2, tb.cx + tb.w / 2, tb.cy + tb.h / 2);
+    const lw = Math.max(labelW(tb.transition.id), labelW(tb.transition.label)) / 2;
+    addBox(tb.cx - lw, tb.cy - tb.h / 2 - C2.LABEL_LINE_H * 2, tb.cx + lw, tb.cy);
+  }
+  for (const ag of arcGeoms) {
+    ag.points.forEach(addPt);
+    if (ag.weight > 1) addBox(ag.labelX - 6, ag.labelY - 8, ag.labelX + 6, ag.labelY + 4);
+  }
+  const dx = C2.MARGIN - bb.minX;
+  const dy = C2.MARGIN - bb.minY;
+  const shift = (p) => ({ x: p.x + dx, y: p.y + dy });
+  placeBoxes.forEach((pb) => {
+    pb.cx += dx;
+    pb.cy += dy;
+  });
+  transBoxes.forEach((tb) => {
+    tb.cx += dx;
+    tb.cy += dy;
+  });
+  arcGeoms.forEach((ag) => {
+    ag.points = ag.points.map(shift);
+    ag.labelX += dx;
+    ag.labelY += dy;
+  });
+  const width = bb.maxX - bb.minX + 2 * C2.MARGIN;
+  const height = bb.maxY - bb.minY + 2 * C2.MARGIN;
+  const subclass = detectSubclass(ast);
+  return {
+    width: Math.round(width),
+    height: Math.round(height),
+    title: ast.title,
+    direction: dir,
+    places: placeBoxes,
+    transitions: transBoxes,
+    arcs: arcGeoms,
+    subclass,
+    enabledIds,
+    warnings,
+    ast
+  };
+}
+function detectSubclass(ast) {
+  if (!ast.transitions.length || !ast.places.length) return void 0;
+  const inT = (tid) => ast.arcs.filter((a) => a.to === tid).length;
+  const outT = (tid) => ast.arcs.filter((a) => a.from === tid).length;
+  const inP = (pid2) => ast.arcs.filter((a) => a.to === pid2).length;
+  const outP = (pid2) => ast.arcs.filter((a) => a.from === pid2).length;
+  const stateMachine = ast.transitions.every((t) => inT(t.id) === 1 && outT(t.id) === 1);
+  const markedGraph = ast.places.every((p) => inP(p.id) === 1 && outP(p.id) === 1);
+  const sources = ast.places.filter((p) => inP(p.id) === 0);
+  const sinks = ast.places.filter((p) => outP(p.id) === 0);
+  const workflowNet = sources.length === 1 && sinks.length === 1;
+  const tags = [];
+  if (stateMachine) tags.push("state machine");
+  if (markedGraph) tags.push("marked graph");
+  if (workflowNet) tags.push("workflow net");
+  return tags.length ? tags.join(", ") : void 0;
+}
+
+// src/diagrams/petri/renderer.ts
+function buildCss6(t) {
+  return `
+.sx-petri { font-family: system-ui, -apple-system, sans-serif; }
+.sx-petri-place { fill: ${t.placeFill}; stroke: ${t.placeStroke}; stroke-width: 2; }
+.sx-petri-place-cap { stroke-dasharray: 4 3; }
+.sx-petri-token { fill: ${t.tokenFill}; stroke: none; }
+.sx-petri-token-num { font: 600 11px sans-serif; fill: ${t.tokenFill}; }
+.sx-petri-bar { fill: ${t.transitionBarFill}; stroke: ${t.transitionStroke}; stroke-width: 2; }
+.sx-petri-box { fill: ${t.transitionBoxFill}; stroke: ${t.transitionStroke}; stroke-width: 2; }
+.sx-petri-enabled { fill: ${t.enabledFill}; stroke: ${t.enabledStroke}; stroke-width: 3; }
+.sx-petri-dead .sx-petri-bar, .sx-petri-dead .sx-petri-box { stroke: ${t.deadStroke}; }
+.sx-petri-dead { opacity: 0.7; }
+.sx-petri-label { font: 12px sans-serif; fill: ${t.text}; }
+.sx-petri-sublabel { font: italic 10px sans-serif; fill: ${t.textMuted}; }
+.sx-petri-cap { font: 9px sans-serif; fill: ${t.textMuted}; }
+.sx-petri-rate { font: italic 9px sans-serif; fill: ${t.textMuted}; }
+.sx-petri-arc { stroke: ${t.arcStroke}; stroke-width: 2; fill: none; }
+.sx-petri-arc-inhibitor, .sx-petri-arc-reset { stroke: ${t.inhibitorStroke}; }
+.sx-petri-inhibitor-dot { fill: ${t.placeFill}; stroke: ${t.inhibitorStroke}; stroke-width: 2; }
+.sx-petri-weight { font: 600 9px sans-serif; fill: ${t.weightLabel}; }
+.sx-petri-title { font: 700 16px sans-serif; fill: ${t.text}; }
+`.trim();
+}
+function markers4(t) {
+  return defs([
+    el(
+      "marker",
+      { id: "sx-petri-head", viewBox: "0 0 10 10", refX: 9, refY: 5, markerWidth: 8, markerHeight: 8, orient: "auto-start-reverse" },
+      [polygon({ points: "0,0 9,5 0,10", fill: t.arcStroke })]
+    ),
+    el(
+      "marker",
+      { id: "sx-petri-head-reset", viewBox: "0 0 16 10", refX: 15, refY: 5, markerWidth: 13, markerHeight: 9, orient: "auto-start-reverse" },
+      [
+        polygon({ points: "0,0 7,5 0,10", fill: t.inhibitorStroke }),
+        polygon({ points: "7,0 14,5 7,10", fill: t.inhibitorStroke })
+      ]
+    )
+  ]);
+}
+function tokenPositions(n) {
+  const d = PETRI_CONST.TOKEN_R + 2.2;
+  switch (n) {
+    case 1:
+      return [{ x: 0, y: 0 }];
+    case 2:
+      return [
+        { x: -d, y: 0 },
+        { x: d, y: 0 }
+      ];
+    case 3:
+      return [
+        { x: 0, y: -d },
+        { x: -d, y: d },
+        { x: d, y: d }
+      ];
+    default:
+      return [
+        { x: -d, y: -d },
+        { x: d, y: -d },
+        { x: -d, y: d },
+        { x: d, y: d }
+      ];
+  }
+}
+function renderTokens(pb, style) {
+  const n = pb.tokens;
+  if (n <= 0) return "";
+  const asDots = style !== "count" && n <= PETRI_CONST.TOKEN_COUNT_MAX_DOTS;
+  if (asDots) {
+    return tokenPositions(n).map((p) => circle({ class: "sx-petri-token", cx: pb.cx + p.x, cy: pb.cy + p.y, r: PETRI_CONST.TOKEN_R })).join("");
+  }
+  return text(
+    { class: "sx-petri-token-num", x: pb.cx, y: pb.cy + 4, "text-anchor": "middle" },
+    String(n)
+  );
+}
+function renderPlace(pb, style) {
+  const cls = pb.place.capacity !== void 0 ? "sx-petri-place sx-petri-place-cap" : "sx-petri-place";
+  const parts = [circle({ class: cls, cx: pb.cx, cy: pb.cy, r: pb.r })];
+  parts.push(renderTokens(pb, style));
+  const labelY = pb.cy - pb.r - PETRI_CONST.LABEL_GAP;
+  parts.push(text({ class: "sx-petri-label", x: pb.cx, y: labelY, "text-anchor": "middle" }, pb.place.id));
+  if (pb.place.label) {
+    parts.push(
+      text({ class: "sx-petri-sublabel", x: pb.cx, y: labelY - PETRI_CONST.LABEL_LINE_H, "text-anchor": "middle" }, pb.place.label)
+    );
+  }
+  if (pb.place.capacity !== void 0) {
+    parts.push(
+      text({ class: "sx-petri-cap", x: pb.cx + pb.r + 3, y: pb.cy + pb.r + 9 }, `K=${pb.place.capacity}`)
+    );
+  }
+  const attrs = {
+    class: "sx-petri-place-g",
+    "data-id": pb.place.id,
+    "data-tokens": pb.tokens
+  };
+  if (pb.place.capacity !== void 0) attrs["data-capacity"] = pb.place.capacity;
+  if (pb.isSource) attrs["data-source"] = "true";
+  if (pb.isSink) attrs["data-sink"] = "true";
+  return group(attrs, parts);
+}
+function renderTransition(tb) {
+  const x = tb.cx - tb.w / 2;
+  const y = tb.cy - tb.h / 2;
+  const parts = [];
+  if (tb.enabled) {
+    parts.push(
+      rect({ class: "sx-petri-enabled", x: x - 4, y: y - 4, width: tb.w + 8, height: tb.h + 8, rx: 4, ry: 4 })
+    );
+  }
+  const shapeClass = tb.transition.kind === "timed" ? "sx-petri-box" : "sx-petri-bar";
+  parts.push(rect({ class: shapeClass, x, y, width: tb.w, height: tb.h, rx: 1, ry: 1 }));
+  const labelY = y - PETRI_CONST.LABEL_GAP;
+  parts.push(text({ class: "sx-petri-label", x: tb.cx, y: labelY, "text-anchor": "middle" }, tb.transition.id));
+  if (tb.transition.label) {
+    parts.push(
+      text({ class: "sx-petri-sublabel", x: tb.cx, y: labelY - PETRI_CONST.LABEL_LINE_H, "text-anchor": "middle" }, tb.transition.label)
+    );
+  }
+  if (tb.transition.kind === "timed" && tb.transition.rate !== void 0) {
+    parts.push(text({ class: "sx-petri-rate", x: tb.cx, y: y + tb.h + 10, "text-anchor": "middle" }, `\u03BB=${tb.transition.rate}`));
+  }
+  if (tb.transition.guard) {
+    parts.push(text({ class: "sx-petri-rate", x: tb.cx + tb.w / 2 + 4, y: tb.cy + 3 }, `[${tb.transition.guard}]`));
+  }
+  return group(
+    {
+      class: tb.dead ? "sx-petri-trans-g sx-petri-dead" : "sx-petri-trans-g",
+      "data-id": tb.transition.id,
+      "data-kind": tb.transition.kind,
+      "data-enabled": tb.enabled ? "true" : "false"
+    },
+    parts
+  );
+}
+function arcPath(ag) {
+  const p = ag.points;
+  if (p.length === 4) {
+    return `M ${p[0].x} ${p[0].y} C ${p[1].x} ${p[1].y} ${p[2].x} ${p[2].y} ${p[3].x} ${p[3].y}`;
+  }
+  return `M ${p[0].x} ${p[0].y} L ${p[p.length - 1].x} ${p[p.length - 1].y}`;
+}
+function renderArc(ag) {
+  const parts = [];
+  let cls = "sx-petri-arc";
+  let markerEnd;
+  if (ag.type === "standard") {
+    markerEnd = "url(#sx-petri-head)";
+  } else if (ag.type === "reset") {
+    cls += " sx-petri-arc-reset";
+    markerEnd = "url(#sx-petri-head-reset)";
+  } else if (ag.type === "inhibitor") {
+    cls += " sx-petri-arc-inhibitor";
+  }
+  parts.push(path({ class: cls, d: arcPath(ag), ...markerEnd ? { "marker-end": markerEnd } : {} }));
+  if (ag.type === "inhibitor") {
+    const pts = ag.points;
+    const last = pts[pts.length - 1];
+    const prev = pts[pts.length - 2];
+    const dx = last.x - prev.x;
+    const dy = last.y - prev.y;
+    const len = Math.hypot(dx, dy) || 1;
+    const r = 4;
+    const cx = last.x - dx / len * r;
+    const cy = last.y - dy / len * r;
+    parts.push(circle({ class: "sx-petri-inhibitor-dot", cx, cy, r }));
+  }
+  if (ag.weight > 1) {
+    parts.push(
+      text({ class: "sx-petri-weight", x: ag.labelX, y: ag.labelY + 3, "text-anchor": "middle" }, String(ag.weight))
+    );
+  }
+  return group(
+    { class: "sx-petri-arc-g", "data-from": ag.arc.from, "data-to": ag.arc.to, "data-type": ag.type, "data-weight": ag.weight },
+    parts
+  );
+}
+function renderPetriLayout(layout, config) {
+  const t = resolvePetriTheme(config?.theme ?? "default");
+  const children = [];
+  const marking = layout.places.filter((p) => p.tokens > 0).map((p) => `${p.place.id}:${p.tokens}`).join(", ");
+  const descParts = [
+    `${layout.places.length} places, ${layout.transitions.length} transitions, ${layout.arcs.length} arcs.`,
+    marking ? `Marking {${marking}}.` : "Empty marking.",
+    layout.enabledIds.length ? `Enabled: ${layout.enabledIds.join(", ")}.` : "No enabled transitions.",
+    layout.subclass ? `Class: ${layout.subclass}.` : ""
+  ].filter(Boolean);
+  children.push(title(`Petri net${layout.title ? " \u2014 " + layout.title : ""}`));
+  children.push(desc(descParts.join(" ")));
+  children.push(el("style", {}, buildCss6(t)));
+  children.push(markers4(t));
+  const titleBand = layout.title ? 32 : 0;
+  if (layout.title) {
+    children.push(text({ x: layout.width / 2, y: 22, class: "sx-petri-title", "text-anchor": "middle" }, layout.title));
+  }
+  const body = [];
+  body.push(group({ class: "sx-petri-arcs" }, layout.arcs.map(renderArc)));
+  body.push(group({ class: "sx-petri-places" }, layout.places.map((p) => renderPlace(p, layout.ast.tokenStyle))));
+  body.push(group({ class: "sx-petri-transitions" }, layout.transitions.map(renderTransition)));
+  children.push(titleBand ? group({ transform: `translate(0, ${titleBand})` }, body) : group({}, body));
+  const height = layout.height + titleBand;
+  return svgRoot(
+    {
+      class: "sx-petri",
+      role: "img",
+      "aria-label": escapeXml(layout.title ?? "Petri net"),
+      width: layout.width,
+      height,
+      viewBox: `0 0 ${layout.width} ${height}`,
+      "data-diagram-type": "petri"
+    },
+    children
+  );
+}
+function renderPetri(textOrAst, config) {
+  const ast = typeof textOrAst === "string" ? parsePetri(textOrAst) : textOrAst;
+  const layout = layoutPetri(ast);
+  return renderPetriLayout(layout, config);
+}
+
+// src/diagrams/petri/index.ts
+var petri = {
+  type: "petri",
+  detect(text2) {
+    for (const raw of text2.split(/\r?\n/)) {
+      const t = raw.trim();
+      if (!t) continue;
+      if (t.startsWith("#") || t.startsWith("//")) continue;
+      return /^petri(net)?\b/i.test(t);
+    }
+    return false;
+  },
+  parse: parsePetri,
+  render(text2, config) {
+    return renderPetri(text2, config);
+  }
+};
+
+// src/diagrams/network/parser.ts
+var NetworkParseError = class extends Error {
+  name = "NetworkParseError";
+};
+var DEVICE_KINDS = /* @__PURE__ */ new Set([
+  "router",
+  "switch",
+  "l3switch",
+  "firewall",
+  "loadbalancer",
+  "ap",
+  "wlc",
+  "gateway",
+  "modem",
+  "ids",
+  "proxy",
+  "vpngw",
+  "server",
+  "serverfarm",
+  "pc",
+  "laptop",
+  "mobile",
+  "ipphone",
+  "printer",
+  "storage",
+  "camera",
+  "nvr",
+  "dvr",
+  "poeswitch",
+  "encoder",
+  "monitor",
+  "internet",
+  "wan",
+  "cloud",
+  "pstn",
+  "lan"
+]);
+var KIND_ALIASES = {
+  multilayer: "l3switch",
+  wifi: "ap",
+  workstation: "pc",
+  phone: "mobile",
+  voip: "ipphone",
+  nas: "storage",
+  san: "storage",
+  servers: "serverfarm",
+  ips: "ids",
+  decoder: "encoder",
+  videowall: "monitor",
+  segment: "lan"
+};
+var GROUP_KINDS = /* @__PURE__ */ new Set(["site", "building", "campus", "rack", "subnet", "vlan", "zone", "dmz"]);
+var GROUP_KIND_ALIAS = { building: "site", campus: "site" };
+var TIERS = /* @__PURE__ */ new Set(["edge", "core", "distribution", "access"]);
+var CAMERA_TYPES = /* @__PURE__ */ new Set(["fixed", "bullet", "dome", "ptz", "turret"]);
+var LAYOUT_MODES = /* @__PURE__ */ new Set([
+  "tiered",
+  "tree",
+  "star",
+  "ring",
+  "bus",
+  "mesh",
+  "spine-leaf",
+  "manual"
+]);
+var LINK_TYPE_KEYWORDS = {
+  copper: "copper",
+  ethernet: "copper",
+  fiber: "fiber",
+  fibre: "fiber",
+  wireless: "wireless",
+  wifi: "wireless",
+  serial: "serial",
+  wan: "serial",
+  poe: "poe",
+  vpn: "vpn",
+  lag: "lag",
+  portchannel: "lag"
+};
+var CONNECTORS = /* @__PURE__ */ new Set(["--", "->", "=="]);
+var SPEED_RE = /^\d+(?:\.\d+)?[MGT]$/;
+var QUOTE_RE = /"([^"]*)"|「([^」]*)」|『([^』]*)』|“([^”]*)”|«([^»]*)»|'([^']*)'/g;
+function stripComment2(line2) {
+  let inQuote = false;
+  let close = "";
+  const pairs = { '"': '"', "\u300C": "\u300D", "\u300E": "\u300F", "\u201C": "\u201D", "\xAB": "\xBB", "'": "'" };
+  for (let i = 0; i < line2.length; i++) {
+    const ch = line2[i];
+    if (inQuote) {
+      if (ch === close) inQuote = false;
+      continue;
+    }
+    if (pairs[ch]) {
+      inQuote = true;
+      close = pairs[ch];
+      continue;
+    }
+    if (ch === "#") return line2.slice(0, i);
+    if (ch === "/" && line2[i + 1] === "/") return line2.slice(0, i);
+  }
+  return line2;
+}
+function splitStatements(line2) {
+  const out = [];
+  let buf = "";
+  let inQuote = false;
+  let close = "";
+  const pairs = { '"': '"', "\u300C": "\u300D", "\u300E": "\u300F", "\u201C": "\u201D", "\xAB": "\xBB", "'": "'" };
+  for (let i = 0; i < line2.length; i++) {
+    const ch = line2[i];
+    if (inQuote) {
+      if (ch === close) inQuote = false;
+      buf += ch;
+      continue;
+    }
+    if (pairs[ch]) {
+      inQuote = true;
+      close = pairs[ch];
+      buf += ch;
+      continue;
+    }
+    if (ch === ";") {
+      out.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  out.push(buf);
+  return out;
+}
+function tokenize4(raw) {
+  const line2 = stripComment2(raw);
+  const strings = [];
+  const masked = line2.replace(QUOTE_RE, (...m) => {
+    const inner = m.slice(1, 7).find((g) => g !== void 0) ?? "";
+    strings.push(inner);
+    return ` @@${strings.length - 1}@@ `;
+  });
+  const spaced = masked.replace(/(--|->|==)/g, " $1 ");
+  const out = [];
+  for (const w of spaced.split(/\s+/)) {
+    if (!w) continue;
+    const sm = /^@@(\d+)@@$/.exec(w);
+    if (sm) {
+      out.push({ value: strings[Number(sm[1])] ?? "", str: true });
+    } else {
+      out.push({ value: w, str: false });
+    }
+  }
+  return out;
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const d = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+  for (let j = 0; j <= n; j++) d[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+    }
+  }
+  return d[m][n];
+}
+function nearestKind(bad) {
+  let best;
+  let bestDist = Infinity;
+  for (const k of [...DEVICE_KINDS, ...Object.keys(KIND_ALIASES)]) {
+    const dist = levenshtein(bad.toLowerCase(), k);
+    if (dist < bestDist) {
+      bestDist = dist;
+      best = k;
+    }
+  }
+  return bestDist <= 3 ? best : void 0;
+}
+function ipToInt(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let v = 0;
+  for (const p of parts) {
+    const n = Number(p);
+    if (!Number.isInteger(n) || n < 0 || n > 255) return null;
+    v = v * 256 + n;
+  }
+  return v >>> 0;
+}
+function ipInCidr(ip, cidr) {
+  const m = /^(\d+\.\d+\.\d+\.\d+)\s*\/\s*(\d+)$/.exec(cidr.trim());
+  if (!m) return null;
+  const netInt = ipToInt(m[1]);
+  const prefix = Number(m[2]);
+  const hostInt = ipToInt(ip.split("/")[0]);
+  if (netInt === null || hostInt === null || prefix < 0 || prefix > 32) return null;
+  const mask = prefix === 0 ? 0 : 4294967295 << 32 - prefix >>> 0;
+  return (netInt & mask) === (hostInt & mask);
+}
+var SWITCH_CLASS = /* @__PURE__ */ new Set(["switch", "l3switch", "poeswitch"]);
+function parseNetwork(text2) {
+  const ast = {
+    type: "network",
+    layout: "tiered",
+    direction: "tb",
+    spines: [],
+    leaves: [],
+    devices: [],
+    links: [],
+    groups: [],
+    warnings: []
+  };
+  const deviceById = /* @__PURE__ */ new Map();
+  const groupById = /* @__PURE__ */ new Map();
+  const groupStack = [];
+  let headerSeen = false;
+  const rawLines = text2.split(/\r?\n/);
+  const addDevice = (d, lineNo) => {
+    if (deviceById.has(d.id)) {
+      throw new NetworkParseError(`device id "${d.id}" already declared (line ${lineNo})`);
+    }
+    deviceById.set(d.id, d);
+    ast.devices.push(d);
+    const top = groupStack[groupStack.length - 1];
+    if (top && !top.members.includes(d.id)) top.members.push(d.id);
+  };
+  const ensureDevice = (id, kind) => {
+    let d = deviceById.get(id);
+    if (!d) {
+      d = { id, kind, groups: [] };
+      deviceById.set(id, d);
+      ast.devices.push(d);
+    }
+    return d;
+  };
+  const applyAttrs = (d, toks, start, lineNo) => {
+    let i = start;
+    while (i < toks.length) {
+      const tk = toks[i];
+      if (tk.str) {
+        i++;
+        continue;
+      }
+      const key = tk.value.endsWith(":") ? tk.value.slice(0, -1) : null;
+      if (key === null) {
+        i++;
+        continue;
+      }
+      const val = toks[i + 1];
+      i += 2;
+      if (!val) continue;
+      switch (key) {
+        case "tier":
+          if (TIERS.has(val.value)) d.tier = val.value;
+          break;
+        case "type":
+          if (CAMERA_TYPES.has(val.value)) d.cameraType = val.value;
+          break;
+        case "ip":
+          d.ip = val.value;
+          break;
+        case "model":
+          d.model = val.value;
+          break;
+        case "count": {
+          const n = Number(val.value);
+          if (Number.isFinite(n)) d.count = n;
+          break;
+        }
+        case "icon":
+          d.icon = val.value;
+          break;
+        case "at": {
+          const mm = /^(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)$/.exec(val.value);
+          if (mm) d.at = { x: Number(mm[1]), y: Number(mm[2]) };
+          break;
+        }
+        default:
+          ast.warnings.push(`unknown attribute "${key}:" on device "${d.id}" (line ${lineNo})`);
+      }
+    }
+  };
+  const statements = [];
+  rawLines.forEach((raw, i) => {
+    for (const seg of splitStatements(stripComment2(raw))) statements.push({ text: seg, no: i + 1 });
+  });
+  for (const stmt of statements) {
+    const lineNo = stmt.no;
+    const toks = tokenize4(stmt.text);
+    if (toks.length === 0) continue;
+    const t0 = toks[0];
+    if (!headerSeen) {
+      if (!t0.str && /^(network|topology)$/i.test(t0.value)) {
+        headerSeen = true;
+        if (toks[1]?.str) ast.title = toks[1].value;
+        continue;
+      }
+      throw new NetworkParseError(
+        `network diagram must start with "network" or "topology" (line ${lineNo})`
+      );
+    }
+    if (toks.length === 1 && t0.value === "}") {
+      if (groupStack.length === 0) {
+        throw new NetworkParseError(`unmatched "}" (line ${lineNo})`);
+      }
+      groupStack.pop();
+      continue;
+    }
+    if (!t0.str && t0.value.endsWith(":")) {
+      const key = t0.value.slice(0, -1).toLowerCase();
+      const rest = toks.slice(1);
+      switch (key) {
+        case "layout": {
+          const v = rest[0]?.value;
+          if (v && LAYOUT_MODES.has(v)) ast.layout = v;
+          else if (v) ast.warnings.push(`unknown layout "${v}" \u2014 using "tiered" (line ${lineNo})`);
+          break;
+        }
+        case "direction": {
+          const v = rest[0]?.value?.toLowerCase();
+          if (v === "tb" || v === "lr") ast.direction = v;
+          break;
+        }
+        case "title":
+          if (rest[0]) ast.title = rest[0].value;
+          break;
+        case "spines":
+          ast.spines.push(...rest.filter((r) => !r.str).map((r) => r.value));
+          break;
+        case "leaves":
+          ast.leaves.push(...rest.filter((r) => !r.str).map((r) => r.value));
+          break;
+        case "legend":
+          break;
+        // parsed-and-ignored in v0.1
+        default:
+          ast.warnings.push(`unknown directive "${key}:" (line ${lineNo})`);
+      }
+      continue;
+    }
+    const ci = toks.findIndex((t) => !t.str && CONNECTORS.has(t.value));
+    if (ci >= 0) {
+      const fromT = toks[ci - 1];
+      const toT = toks[ci + 1];
+      if (!fromT || !toT || fromT.str || toT.str) {
+        throw new NetworkParseError(`malformed link (line ${lineNo})`);
+      }
+      const conn = toks[ci].value;
+      const link = {
+        from: fromT.value,
+        to: toT.value,
+        directed: conn === "->",
+        linkType: conn === "==" ? "lag" : "copper",
+        line: lineNo
+      };
+      let si = ci + 2;
+      if (toks[si] && !toks[si].str && toks[si].value === ":") si++;
+      while (si < toks.length) {
+        const tk = toks[si];
+        if (tk.str) {
+          link.label = tk.value;
+          si++;
+          continue;
+        }
+        const low = tk.value.toLowerCase();
+        if (LINK_TYPE_KEYWORDS[low]) {
+          link.linkType = LINK_TYPE_KEYWORDS[low];
+          si++;
+          continue;
+        }
+        if (low === "trunk" || low === "access") {
+          link.mode = low;
+          si++;
+          continue;
+        }
+        if (SPEED_RE.test(tk.value)) {
+          link.speed = tk.value;
+          si++;
+          continue;
+        }
+        if (low === "vlan:") {
+          const v = toks[si + 1];
+          if (v) {
+            link.vlans = v.value.split(",").map((s) => Number(s.trim())).filter((n) => Number.isFinite(n));
+            for (const vid of link.vlans) {
+              if (vid < 1 || vid > 4094) {
+                ast.warnings.push(`VLAN id ${vid} out of range 1\u20134094 (line ${lineNo})`);
+              }
+            }
+          }
+          si += 2;
+          continue;
+        }
+        if (low === "port:") {
+          const v = toks[si + 1];
+          if (v) {
+            const [near, far] = v.value.split(">");
+            link.portNear = near;
+            if (far) link.portFar = far;
+          }
+          si += 2;
+          continue;
+        }
+        if (low === "ip:") {
+          link.ip = toks[si + 1]?.value;
+          si += 2;
+          continue;
+        }
+        si++;
+      }
+      ast.links.push(link);
+      continue;
+    }
+    if (!t0.str && GROUP_KINDS.has(t0.value) && toks[toks.length - 1].value === "{") {
+      const idT = toks[1];
+      if (!idT || idT.str) throw new NetworkParseError(`group needs an id (line ${lineNo})`);
+      const kind = GROUP_KIND_ALIAS[t0.value] ?? t0.value;
+      const label = toks[2]?.str ? toks[2].value : void 0;
+      if (groupById.has(idT.value)) {
+        throw new NetworkParseError(`group id "${idT.value}" already declared (line ${lineNo})`);
+      }
+      const parent = groupStack[groupStack.length - 1];
+      const g = {
+        id: idT.value,
+        kind,
+        label,
+        members: [],
+        children: [],
+        parent: parent?.id,
+        line: lineNo
+      };
+      if (parent) parent.children.push(g.id);
+      groupById.set(g.id, g);
+      ast.groups.push(g);
+      groupStack.push(g);
+      continue;
+    }
+    const canonKind = KIND_ALIASES[t0.value] ?? t0.value;
+    if (!t0.str && DEVICE_KINDS.has(canonKind)) {
+      const idT = toks[1];
+      if (!idT || idT.str) throw new NetworkParseError(`device "${t0.value}" needs an id (line ${lineNo})`);
+      let idx = 2;
+      let label;
+      if (toks[2]?.str) {
+        label = toks[2].value;
+        idx = 3;
+      }
+      const d = { id: idT.value, kind: canonKind, label, groups: groupStack.map((g) => g.id) };
+      applyAttrs(d, toks, idx, lineNo);
+      addDevice(d, lineNo);
+      continue;
+    }
+    const sep = toks.findIndex((t) => !t.str && t.value === ":");
+    if (sep > 0) {
+      const ids = toks.slice(0, sep);
+      const kindT = toks[sep + 1];
+      if (kindT && !kindT.str && ids.every((t) => !t.str)) {
+        const k = KIND_ALIASES[kindT.value] ?? kindT.value;
+        if (!DEVICE_KINDS.has(k)) {
+          const hint = nearestKind(kindT.value);
+          throw new NetworkParseError(
+            `unknown device kind "${kindT.value}"${hint ? ` \u2014 did you mean "${hint}"?` : ""} (line ${lineNo})`
+          );
+        }
+        for (const idT of ids) {
+          const d = { id: idT.value, kind: k, groups: groupStack.map((g) => g.id) };
+          applyAttrs(d, toks, sep + 2, lineNo);
+          addDevice(d, lineNo);
+        }
+        continue;
+      }
+    }
+    if (toks.length === 1 && !t0.str && groupStack.length > 0) {
+      const top = groupStack[groupStack.length - 1];
+      if (!top.members.includes(t0.value)) top.members.push(t0.value);
+      continue;
+    }
+    if (!t0.str && toks.length >= 2 && !toks[1].str) {
+      const hint = nearestKind(t0.value);
+      throw new NetworkParseError(
+        `unknown device kind "${t0.value}"${hint ? ` \u2014 did you mean "${hint}"?` : ""} (line ${lineNo})`
+      );
+    }
+    throw new NetworkParseError(`cannot parse line ${lineNo}: "${stmt.text.trim()}"`);
+  }
+  if (groupStack.length > 0) {
+    throw new NetworkParseError(`unclosed group "${groupStack[groupStack.length - 1].id}"`);
+  }
+  for (const id of ast.spines) ensureDevice(id, "l3switch");
+  for (const id of ast.leaves) ensureDevice(id, "switch");
+  for (const link of ast.links) {
+    for (const end of [link.from, link.to]) {
+      if (!deviceById.has(end)) {
+        throw new NetworkParseError(
+          `link references undeclared device "${end}" (line ${link.line ?? "?"})`
+        );
+      }
+    }
+    if (link.mode === "trunk") {
+      const a = deviceById.get(link.from), b = deviceById.get(link.to);
+      if (!SWITCH_CLASS.has(a.kind) && !SWITCH_CLASS.has(b.kind)) {
+        ast.warnings.push(`trunk link ${link.from}\u2013${link.to} connects no switch-class device (line ${link.line ?? "?"})`);
+      }
+    }
+  }
+  for (const g of ast.groups) {
+    if (g.kind !== "subnet" || !g.label) continue;
+    for (const memberId of g.members) {
+      const d = deviceById.get(memberId);
+      if (!d?.ip) continue;
+      const inside = ipInCidr(d.ip, g.label);
+      if (inside === false) {
+        throw new NetworkParseError(
+          `${d.id} ip ${d.ip} is not inside subnet ${g.label} (line ${d.line ?? g.line ?? "?"})`
+        );
+      }
+    }
+  }
+  return ast;
+}
+
+// src/diagrams/network/symbols.ts
+var BODY = "sx-net-body";
+var DET = "sx-net-detail";
+var GLY = "sx-net-glyph";
+var GLYL = "sx-net-glyph-line";
+var ITX = "sx-net-icontext";
+var CLOUD = "sx-net-cloud-body";
+var CTX = "sx-net-cloudtext";
+var r2 = (n) => Math.round(n * 100) / 100;
+function arrow(x1, y1, x2, y2, hs = 4) {
+  const ang = Math.atan2(y2 - y1, x2 - x1);
+  const a1 = ang + Math.PI - 0.5;
+  const a2 = ang + Math.PI + 0.5;
+  const p1x = r2(x2 + hs * Math.cos(a1)), p1y = r2(y2 + hs * Math.sin(a1));
+  const p2x = r2(x2 + hs * Math.cos(a2)), p2y = r2(y2 + hs * Math.sin(a2));
+  return line({ class: GLYL, x1: r2(x1), y1: r2(y1), x2: r2(x2), y2: r2(y2) }) + polygon({ class: GLY, points: `${r2(x2)},${r2(y2)} ${p1x},${p1y} ${p2x},${p2y}` });
+}
+function router(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.78, rh = b.h * 0.62;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  const parts = [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: rh / 2, ry: rh / 2 })
+  ];
+  parts.push(arrow(cx - 2, cy - rh * 0.18, x + rw - 5, cy - rh * 0.18));
+  parts.push(arrow(cx + 2, cy + rh * 0.18, x + 5, cy + rh * 0.18));
+  parts.push(arrow(cx + rw * 0.18, cy + 2, cx + rw * 0.18, y + rh - 4));
+  parts.push(arrow(cx - rw * 0.18, cy - 2, cx - rw * 0.18, y + 4));
+  return group({}, parts);
+}
+function switchBox(b, glyph) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.86, rh = b.h * 0.5;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  const parts = [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 3, ry: 3 })
+  ];
+  if (glyph === "circular") {
+    parts.push(arrow(x + rw * 0.25, cy - rh * 0.16, x + rw * 0.75, cy - rh * 0.16));
+    parts.push(arrow(x + rw * 0.75, cy + rh * 0.16, x + rw * 0.25, cy + rh * 0.16));
+    parts.push(arrow(x + rw * 0.62, cy - rh * 0.16, x + rw * 0.78, cy - rh * 0.16));
+  } else {
+    parts.push(arrow(x + rw * 0.2, cy - rh * 0.18, x + rw * 0.8, cy - rh * 0.18));
+    parts.push(arrow(x + rw * 0.8, cy + rh * 0.18, x + rw * 0.2, cy + rh * 0.18));
+  }
+  return group({}, parts);
+}
+function poeSwitch(b) {
+  const cx = b.x + b.w / 2;
+  return group({}, [switchBox(b, "straight"), text({ class: ITX, x: r2(cx), y: r2(b.y + b.h * 0.78 + 8), "text-anchor": "middle" }, "PoE")]);
+}
+function firewall(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.78, rh = b.h * 0.62;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  const parts = [rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 2, ry: 2 })];
+  const rows = 3;
+  const rhh = rh / rows;
+  for (let i = 1; i < rows; i++) parts.push(line({ class: DET, x1: r2(x), y1: r2(y + i * rhh), x2: r2(x + rw), y2: r2(y + i * rhh) }));
+  for (let i = 0; i < rows; i++) {
+    const yy = y + i * rhh;
+    const offset = i % 2 === 0 ? rw / 3 : rw / 6;
+    for (let vx = x + offset; vx < x + rw - 2; vx += rw / 3) {
+      parts.push(line({ class: DET, x1: r2(vx), y1: r2(yy), x2: r2(vx), y2: r2(yy + rhh) }));
+    }
+  }
+  return group({}, parts);
+}
+function brickless(b, glyph) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.78, rh = b.h * 0.6;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  return group({}, [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 3, ry: 3 }),
+    text({ class: ITX, x: r2(cx), y: r2(cy + 4), "text-anchor": "middle" }, glyph)
+  ]);
+}
+function accessPoint(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h * 0.62;
+  const rw = b.w * 0.5, rh = b.h * 0.34;
+  const parts = [
+    rect({ class: BODY, x: r2(cx - rw / 2), y: r2(cy - rh / 2), width: r2(rw), height: r2(rh), rx: rh / 2, ry: rh / 2 })
+  ];
+  for (let i = 1; i <= 2; i++) {
+    const rr = i * b.w * 0.16;
+    parts.push(path({ class: GLYL, d: `M ${r2(cx - rr)} ${r2(cy - rh / 2 - 2)} A ${r2(rr)} ${r2(rr)} 0 0 1 ${r2(cx + rr)} ${r2(cy - rh / 2 - 2)}` }));
+  }
+  return group({}, parts);
+}
+function server(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.46, rh = b.h * 0.82;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  const parts = [rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 2, ry: 2 })];
+  for (let i = 1; i <= 3; i++) parts.push(line({ class: DET, x1: r2(x + 4), y1: r2(y + i * (rh / 4)), x2: r2(x + rw - 4), y2: r2(y + i * (rh / 4)) }));
+  parts.push(circle({ class: GLY, cx: r2(x + rw - 7), cy: r2(y + 6), r: 1.6 }));
+  return group({}, parts);
+}
+function serverFarm(b, d) {
+  const parts = [];
+  const off = Math.min(6, b.w * 0.1);
+  for (let i = 2; i >= 0; i--) {
+    parts.push(server({ x: b.x + i * off, y: b.y - i * off * 0.5, w: b.w - 2 * off, h: b.h - off }));
+  }
+  if (d.count) parts.push(text({ class: ITX, x: r2(b.x + b.w - 6), y: r2(b.y + b.h - 2), "text-anchor": "end" }, `\xD7${d.count}`));
+  return group({}, parts);
+}
+function pc(b) {
+  const cx = b.x + b.w / 2;
+  const sw = b.w * 0.7, sh = b.h * 0.52;
+  const sx = cx - sw / 2, sy = b.y + b.h * 0.12;
+  return group({}, [
+    rect({ class: BODY, x: r2(sx), y: r2(sy), width: r2(sw), height: r2(sh), rx: 2, ry: 2 }),
+    rect({ class: DET, x: r2(sx + 3), y: r2(sy + 3), width: r2(sw - 6), height: r2(sh - 6), rx: 1, ry: 1, fill: "none" }),
+    line({ class: DET, x1: r2(cx), y1: r2(sy + sh), x2: r2(cx), y2: r2(sy + sh + b.h * 0.16) }),
+    line({ class: DET, x1: r2(cx - sw * 0.28), y1: r2(b.y + b.h - 2), x2: r2(cx + sw * 0.28), y2: r2(b.y + b.h - 2) })
+  ]);
+}
+function laptop(b) {
+  const cx = b.x + b.w / 2;
+  const sw = b.w * 0.6, sh = b.h * 0.46;
+  const sx = cx - sw / 2, sy = b.y + b.h * 0.16;
+  return group({}, [
+    rect({ class: BODY, x: r2(sx), y: r2(sy), width: r2(sw), height: r2(sh), rx: 2, ry: 2 }),
+    polygon({ class: BODY, points: `${r2(sx - sw * 0.18)},${r2(sy + sh + b.h * 0.18)} ${r2(sx + sw + sw * 0.18)},${r2(sy + sh + b.h * 0.18)} ${r2(sx + sw)},${r2(sy + sh)} ${r2(sx)},${r2(sy + sh)}` })
+  ]);
+}
+function mobile(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.32, rh = b.h * 0.82;
+  return group({}, [
+    rect({ class: BODY, x: r2(cx - rw / 2), y: r2(cy - rh / 2), width: r2(rw), height: r2(rh), rx: 3, ry: 3 }),
+    line({ class: DET, x1: r2(cx - rw * 0.2), y1: r2(cy + rh / 2 - 4), x2: r2(cx + rw * 0.2), y2: r2(cy + rh / 2 - 4) })
+  ]);
+}
+function ipphone(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.6, rh = b.h * 0.6;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  return group({}, [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh * 0.7), rx: 2, ry: 2 }),
+    path({ class: GLYL, d: `M ${r2(x + rw * 0.2)} ${r2(y + 5)} q ${r2(rw * 0.3)} ${r2(rh * 0.5)} ${r2(rw * 0.6)} 0` })
+  ]);
+}
+function printer(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.7, rh = b.h * 0.42;
+  const x = cx - rw / 2, y = cy - rh * 0.1;
+  return group({}, [
+    rect({ class: DET, x: r2(x + rw * 0.18), y: r2(y - rh * 0.7), width: r2(rw * 0.64), height: r2(rh * 0.7), fill: "none" }),
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 2, ry: 2 }),
+    rect({ class: DET, x: r2(x + rw * 0.18), y: r2(y + rh - 2), width: r2(rw * 0.64), height: r2(rh * 0.5), fill: "none" }),
+    circle({ class: GLY, cx: r2(x + rw - 7), cy: r2(y + rh / 2), r: 1.6 })
+  ]);
+}
+function storage(b) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.5, rh = b.h * 0.78;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  const ry = rw * 0.18;
+  const parts = [
+    path({ class: BODY, d: `M ${r2(x)} ${r2(y + ry)} A ${r2(rw / 2)} ${r2(ry)} 0 0 1 ${r2(x + rw)} ${r2(y + ry)} L ${r2(x + rw)} ${r2(y + rh - ry)} A ${r2(rw / 2)} ${r2(ry)} 0 0 1 ${r2(x)} ${r2(y + rh - ry)} Z` }),
+    path({ class: DET, fill: "none", d: `M ${r2(x)} ${r2(y + ry)} A ${r2(rw / 2)} ${r2(ry)} 0 0 0 ${r2(x + rw)} ${r2(y + ry)}` })
+  ];
+  return group({}, parts);
+}
+function camera(b, d) {
+  const t = d.cameraType ?? "fixed";
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  if (t === "dome" || t === "ptz") {
+    const rr = b.w * (t === "ptz" ? 0.34 : 0.28);
+    const parts = [
+      path({ class: BODY, d: `M ${r2(cx - rr)} ${r2(cy + rr * 0.2)} A ${r2(rr)} ${r2(rr)} 0 0 1 ${r2(cx + rr)} ${r2(cy + rr * 0.2)} Z` }),
+      rect({ class: BODY, x: r2(cx - rr * 1.15), y: r2(cy + rr * 0.2), width: r2(rr * 2.3), height: r2(b.h * 0.12), rx: 1, ry: 1 }),
+      circle({ class: GLY, cx: r2(cx), cy: r2(cy - rr * 0.15), r: r2(rr * 0.3) })
+    ];
+    return group({}, parts);
+  }
+  if (t === "bullet") {
+    const bw2 = b.w * 0.6, bh2 = b.h * 0.34;
+    const x2 = cx - bw2 / 2, y2 = cy - bh2 / 2;
+    return group({}, [
+      rect({ class: BODY, x: r2(x2), y: r2(y2), width: r2(bw2), height: r2(bh2), rx: bh2 / 2, ry: bh2 / 2 }),
+      circle({ class: GLY, cx: r2(x2 + bw2 - 4), cy: r2(cy), r: r2(bh2 * 0.28) }),
+      line({ class: DET, x1: r2(cx), y1: r2(y2 + bh2), x2: r2(cx), y2: r2(y2 + bh2 + b.h * 0.16) })
+    ]);
+  }
+  const bw = b.w * 0.5, bh = b.h * 0.42;
+  const x = cx - bw / 2, y = cy - bh / 2;
+  return group({}, [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(bw), height: r2(bh), rx: 2, ry: 2 }),
+    circle({ class: GLY, cx: r2(cx), cy: r2(cy), r: r2(bh * 0.3) })
+  ]);
+}
+function recorder(b, label) {
+  const cx = b.x + b.w / 2, cy = b.y + b.h / 2;
+  const rw = b.w * 0.82, rh = b.h * 0.46;
+  const x = cx - rw / 2, y = cy - rh / 2;
+  return group({}, [
+    rect({ class: BODY, x: r2(x), y: r2(y), width: r2(rw), height: r2(rh), rx: 2, ry: 2 }),
+    circle({ class: GLY, cx: r2(x + rw * 0.22), cy: r2(y + rh * 0.32), r: 2 }),
+    circle({ class: GLY, cx: r2(x + rw * 0.4), cy: r2(y + rh * 0.32), r: 2 }),
+    text({ class: ITX, x: r2(cx), y: r2(y + rh * 0.85), "text-anchor": "middle" }, label)
+  ]);
+}
+function monitor(b, grid) {
+  const cx = b.x + b.w / 2;
+  const sw = b.w * 0.84, sh = b.h * 0.56;
+  const sx = cx - sw / 2, sy = b.y + b.h * 0.1;
+  const parts = [rect({ class: BODY, x: r2(sx), y: r2(sy), width: r2(sw), height: r2(sh), rx: 2, ry: 2 })];
+  if (grid) {
+    parts.push(line({ class: DET, x1: r2(cx), y1: r2(sy), x2: r2(cx), y2: r2(sy + sh) }));
+    parts.push(line({ class: DET, x1: r2(sx), y1: r2(sy + sh / 2), x2: r2(sx + sw), y2: r2(sy + sh / 2) }));
+  }
+  parts.push(line({ class: DET, x1: r2(cx), y1: r2(sy + sh), x2: r2(cx), y2: r2(sy + sh + b.h * 0.14) }));
+  parts.push(line({ class: DET, x1: r2(cx - sw * 0.2), y1: r2(b.y + b.h - 2), x2: r2(cx + sw * 0.2), y2: r2(b.y + b.h - 2) }));
+  return group({}, parts);
+}
+function cloud(b, label) {
+  const mx = (dx) => r2(b.x + dx / 200 * b.w);
+  const my = (dy) => r2(b.y + dy / 110 * b.h);
+  const d = `M ${mx(50)} ${my(96)} C ${mx(24)} ${my(96)} ${mx(24)} ${my(62)} ${mx(50)} ${my(58)} C ${mx(50)} ${my(30)} ${mx(94)} ${my(26)} ${mx(100)} ${my(50)} C ${mx(106)} ${my(26)} ${mx(150)} ${my(30)} ${mx(150)} ${my(58)} C ${mx(176)} ${my(62)} ${mx(176)} ${my(96)} ${mx(150)} ${my(96)} Z`;
+  return group({}, [
+    path({ class: CLOUD, d }),
+    text({ class: CTX, x: r2(b.x + b.w / 2), y: my(80), "text-anchor": "middle" }, label)
+  ]);
+}
+function busBar(b) {
+  const y = b.y + b.h / 2;
+  return line({ class: "sx-net-bus", x1: r2(b.x), y1: r2(y), x2: r2(b.x + b.w), y2: r2(y) });
+}
+function iconSize(kind) {
+  if (kind === "internet" || kind === "wan" || kind === "cloud" || kind === "pstn") return { w: 110, h: 64 };
+  if (kind === "lan") return { w: 150, h: 24 };
+  if (kind === "serverfarm") return { w: 74, h: 58 };
+  return { w: 64, h: 48 };
+}
+function drawDeviceIcon(d, b) {
+  switch (d.kind) {
+    case "router":
+      return router(b);
+    case "gateway":
+      return group({}, [router(b), text({ class: ITX, x: r2(b.x + b.w / 2), y: r2(b.y + b.h - 1), "text-anchor": "middle" }, "GW")]);
+    case "vpngw":
+      return group({}, [router(b), text({ class: ITX, x: r2(b.x + b.w / 2), y: r2(b.y + b.h - 1), "text-anchor": "middle" }, "VPN")]);
+    case "switch":
+      return switchBox(b, "straight");
+    case "l3switch":
+      return switchBox(b, "circular");
+    case "poeswitch":
+      return poeSwitch(b);
+    case "firewall":
+      return firewall(b);
+    case "loadbalancer":
+      return brickless(b, "LB");
+    case "ids":
+      return brickless(b, "IDS");
+    case "proxy":
+      return brickless(b, "PXY");
+    case "modem":
+      return brickless(b, "MDM");
+    case "wlc":
+      return brickless(b, "WLC");
+    case "ap":
+      return accessPoint(b);
+    case "server":
+      return server(b);
+    case "serverfarm":
+      return serverFarm(b, d);
+    case "pc":
+      return pc(b);
+    case "laptop":
+      return laptop(b);
+    case "mobile":
+      return mobile(b);
+    case "ipphone":
+      return ipphone(b);
+    case "printer":
+      return printer(b);
+    case "storage":
+      return storage(b);
+    case "camera":
+      return camera(b, d);
+    case "nvr":
+      return recorder(b, "NVR");
+    case "dvr":
+      return recorder(b, "DVR");
+    case "encoder":
+      return brickless(b, "ENC");
+    case "monitor":
+      return monitor(b, d.icon === "videowall");
+    case "internet":
+      return cloud(b, d.label ?? "Internet");
+    case "wan":
+      return cloud(b, d.label ?? "WAN");
+    case "pstn":
+      return cloud(b, d.label ?? "PSTN");
+    case "cloud":
+      return cloud(b, d.label ?? "Cloud");
+    case "lan":
+      return busBar(b);
+    default:
+      return brickless(b, "?");
+  }
+}
+function isCloudKind(kind) {
+  return kind === "internet" || kind === "wan" || kind === "pstn" || kind === "cloud";
+}
+
+// src/diagrams/network/layout.ts
+var NET_CONST = {
+  DEVICE_W: 64,
+  DEVICE_H: 48,
+  TIER_BAND_GAP: 104,
+  SIBLING_GAP: 44,
+  RING_RADIUS_MIN: 120,
+  STAR_HUB_GAP: 130,
+  SPINE_LEAF_GAP: 140,
+  LABEL_GAP: 6,
+  LABEL_H: 15,
+  SUBLABEL_H: 12,
+  GROUP_PAD: 18,
+  GROUP_LABEL_INSET: 12,
+  GROUP_HEADER: 16,
+  CHAR_W: 6.3,
+  PAD: 30
+};
+var ENDPOINT_KINDS = /* @__PURE__ */ new Set([
+  "pc",
+  "laptop",
+  "mobile",
+  "ipphone",
+  "printer",
+  "camera",
+  "server",
+  "serverfarm",
+  "storage",
+  "monitor",
+  "nvr",
+  "dvr"
+]);
+function labelExtra(d) {
+  if (isCloudKind(d.kind)) return 0;
+  let h = NET_CONST.LABEL_GAP + NET_CONST.LABEL_H;
+  if (d.ip || d.model) h += NET_CONST.SUBLABEL_H;
+  return h;
+}
+function labelText(d) {
+  return d.label ?? d.id;
+}
+function deviceFootprint(d) {
+  return iconSize(d.kind);
+}
+function effBox(box) {
+  const labelW = Math.max(box.w, labelText(box.device).length * NET_CONST.CHAR_W + 6);
+  const half = labelW / 2;
+  return {
+    left: box.cx - half,
+    top: box.y,
+    right: box.cx + half,
+    bottom: box.y + box.h + labelExtra(box.device)
+  };
+}
+function edgePoint(box, tx, ty) {
+  const dx = tx - box.cx;
+  const dy = ty - box.cy;
+  if (dx === 0 && dy === 0) return { x: box.cx, y: box.cy };
+  const hw = box.w / 2;
+  const hh = box.h / 2;
+  const sx = dx !== 0 ? hw / Math.abs(dx) : Infinity;
+  const sy = dy !== 0 ? hh / Math.abs(dy) : Infinity;
+  const s = Math.min(sx, sy);
+  return { x: box.cx + dx * s, y: box.cy + dy * s };
+}
+function placeBanded(ast, ranks) {
+  const lr = ast.direction === "lr";
+  const byRank = /* @__PURE__ */ new Map();
+  for (const d of ast.devices) {
+    const r = ranks.get(d.id) ?? 0;
+    if (!byRank.has(r)) byRank.set(r, []);
+    byRank.get(r).push(d);
+  }
+  const rankValues = [...byRank.keys()].sort((a, b) => a - b);
+  const pos = /* @__PURE__ */ new Map();
+  let maxRowSpan = 0;
+  const rowSpans = /* @__PURE__ */ new Map();
+  for (const r of rankValues) {
+    const devs = byRank.get(r);
+    let span = 0;
+    devs.forEach((d, i) => {
+      const fp = deviceFootprint(d);
+      const cross = lr ? fp.h + labelExtra(d) : Math.max(fp.w, labelText(d).length * NET_CONST.CHAR_W + 6);
+      span += cross + (i > 0 ? NET_CONST.SIBLING_GAP : 0);
+    });
+    rowSpans.set(r, span);
+    maxRowSpan = Math.max(maxRowSpan, span);
+  }
+  rankValues.forEach((r, rowIdx) => {
+    const devs = byRank.get(r);
+    const along = rowIdx * NET_CONST.TIER_BAND_GAP;
+    let cursor = (maxRowSpan - rowSpans.get(r)) / 2;
+    for (const d of devs) {
+      const fp = deviceFootprint(d);
+      const cross = lr ? fp.h + labelExtra(d) : Math.max(fp.w, labelText(d).length * NET_CONST.CHAR_W + 6);
+      const center = cursor + cross / 2;
+      if (lr) pos.set(d.id, { x: along, y: center });
+      else pos.set(d.id, { x: center, y: along });
+      cursor += cross + NET_CONST.SIBLING_GAP;
+    }
+  });
+  return pos;
+}
+function adjacency(devices, links) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const d of devices) adj.set(d.id, /* @__PURE__ */ new Set());
+  for (const l of links) {
+    adj.get(l.from)?.add(l.to);
+    adj.get(l.to)?.add(l.from);
+  }
+  return adj;
+}
+function tieredRanks(ast, links) {
+  const TIER_RANK = { edge: 1, core: 2, distribution: 3, access: 4 };
+  const rank = /* @__PURE__ */ new Map();
+  for (const d of ast.devices) {
+    if (isCloudKind(d.kind)) rank.set(d.id, 0);
+    else if (d.tier) rank.set(d.id, TIER_RANK[d.tier]);
+  }
+  const adj = adjacency(ast.devices, links);
+  for (let pass = 0; pass < ast.devices.length + 4; pass++) {
+    let changed = false;
+    for (const d of ast.devices) {
+      if (rank.has(d.id)) continue;
+      const known = [];
+      for (const n of adj.get(d.id) ?? []) {
+        const r = rank.get(n);
+        if (r !== void 0) known.push(r);
+      }
+      if (known.length === 0) continue;
+      const next = ENDPOINT_KINDS.has(d.kind) ? Math.max(...known) + 1 : Math.min(...known) + 1;
+      rank.set(d.id, next);
+      changed = true;
+    }
+    if (!changed) break;
+  }
+  const maxR = Math.max(0, ...[...rank.values()]);
+  for (const d of ast.devices) {
+    if (!rank.has(d.id)) rank.set(d.id, ENDPOINT_KINDS.has(d.kind) ? maxR + 1 : 2);
+  }
+  return rank;
+}
+function treeRanks(ast, links) {
+  const adj = adjacency(ast.devices, links);
+  const rank = /* @__PURE__ */ new Map();
+  let root = ast.devices.find((d) => isCloudKind(d.kind));
+  if (!root) {
+    let best = -1;
+    for (const d of ast.devices) {
+      const deg = adj.get(d.id)?.size ?? 0;
+      if (deg > best) {
+        best = deg;
+        root = d;
+      }
+    }
+  }
+  if (!root) return rank;
+  const queue = [root.id];
+  rank.set(root.id, 0);
+  while (queue.length) {
+    const id = queue.shift();
+    const r = rank.get(id);
+    for (const n of adj.get(id) ?? []) {
+      if (!rank.has(n)) {
+        rank.set(n, r + 1);
+        queue.push(n);
+      }
+    }
+  }
+  for (const d of ast.devices) if (!rank.has(d.id)) rank.set(d.id, 0);
+  return rank;
+}
+function placeCircle(ast, radiusBase) {
+  const pos = /* @__PURE__ */ new Map();
+  const n = ast.devices.length;
+  const radius = Math.max(radiusBase, n * 56 / (2 * Math.PI));
+  ast.devices.forEach((d, i) => {
+    const ang = i / Math.max(1, n) * 2 * Math.PI - Math.PI / 2;
+    pos.set(d.id, { x: radius * Math.cos(ang), y: radius * Math.sin(ang) });
+  });
+  return pos;
+}
+function placeStar(ast, links) {
+  const adj = adjacency(ast.devices, links);
+  let hub = ast.devices[0];
+  let best = -1;
+  for (const d of ast.devices) {
+    const deg = adj.get(d.id)?.size ?? 0;
+    if (deg > best) {
+      best = deg;
+      hub = d;
+    }
+  }
+  const pos = /* @__PURE__ */ new Map();
+  if (!hub) return pos;
+  pos.set(hub.id, { x: 0, y: 0 });
+  const spokes = ast.devices.filter((d) => d.id !== hub.id);
+  const radius = Math.max(NET_CONST.STAR_HUB_GAP, spokes.length * 50 / (2 * Math.PI));
+  spokes.forEach((d, i) => {
+    const ang = i / Math.max(1, spokes.length) * 2 * Math.PI - Math.PI / 2;
+    pos.set(d.id, { x: radius * Math.cos(ang), y: radius * Math.sin(ang) });
+  });
+  return pos;
+}
+function placeBus(ast) {
+  const pos = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  for (const d of ast.devices) {
+    const fp = deviceFootprint(d);
+    pos.set(d.id, { x: cursor + fp.w / 2, y: 0 });
+    cursor += fp.w + NET_CONST.SIBLING_GAP;
+  }
+  return pos;
+}
+function placeSpineLeaf(ast, links) {
+  const pos = /* @__PURE__ */ new Map();
+  const spineSet = new Set(ast.spines);
+  const leafSet = new Set(ast.leaves);
+  const rowGap = NET_CONST.SPINE_LEAF_GAP;
+  const step = NET_CONST.DEVICE_W + NET_CONST.SIBLING_GAP;
+  const centerRow = (ids, y) => {
+    const span = (ids.length - 1) * step;
+    ids.forEach((id, i) => pos.set(id, { x: i * step - span / 2, y }));
+  };
+  centerRow(ast.spines, 0);
+  centerRow(ast.leaves, rowGap);
+  const adj = adjacency(ast.devices, links);
+  const hosts = ast.devices.filter((d) => !spineSet.has(d.id) && !leafSet.has(d.id));
+  let seq = 0;
+  for (const h of hosts) {
+    let anchorX;
+    for (const n of adj.get(h.id) ?? []) {
+      if (leafSet.has(n)) {
+        anchorX = pos.get(n)?.x;
+        break;
+      }
+    }
+    pos.set(h.id, { x: anchorX ?? seq++ * step, y: rowGap * 2 });
+  }
+  return pos;
+}
+function placeManual(ast) {
+  const pos = /* @__PURE__ */ new Map();
+  let fallback = 0;
+  for (const d of ast.devices) {
+    if (d.at) pos.set(d.id, { x: d.at.x, y: d.at.y });
+    else {
+      pos.set(d.id, { x: fallback * 120, y: 0 });
+      fallback++;
+    }
+  }
+  return pos;
+}
+function withAutoLinks(ast) {
+  if (ast.layout !== "spine-leaf" || ast.spines.length === 0 || ast.leaves.length === 0) {
+    return ast.links;
+  }
+  const have = new Set(ast.links.map((l) => [l.from, l.to].sort().join("\u2194")));
+  const extra = [];
+  for (const s of ast.spines) {
+    for (const lf of ast.leaves) {
+      const key = [s, lf].sort().join("\u2194");
+      if (!have.has(key)) {
+        extra.push({ from: s, to: lf, directed: false, linkType: "copper", auto: true });
+        have.add(key);
+      }
+    }
+  }
+  return [...ast.links, ...extra];
+}
+function classify(ast) {
+  if (ast.devices.length === 2 && ast.links.length === 1) return "point-to-point";
+  switch (ast.layout) {
+    case "star":
+      return "star";
+    case "ring":
+      return "ring";
+    case "bus":
+      return "bus";
+    case "mesh":
+      return "mesh";
+    case "spine-leaf":
+      return "spine-leaf";
+    case "tree":
+      return "tree";
+    case "tiered":
+      return ast.devices.some((d) => d.tier) ? "hierarchical" : "tree";
+    default:
+      return "general";
+  }
+}
+function layoutNetwork2(ast) {
+  const links = withAutoLinks(ast);
+  let centers;
+  switch (ast.layout) {
+    case "tree":
+      centers = placeBanded(ast, treeRanks(ast, links));
+      break;
+    case "star":
+      centers = placeStar(ast, links);
+      break;
+    case "ring":
+      centers = placeCircle(ast, NET_CONST.RING_RADIUS_MIN);
+      break;
+    case "mesh":
+      centers = placeCircle(ast, NET_CONST.RING_RADIUS_MIN);
+      break;
+    case "bus":
+      centers = placeBus(ast);
+      break;
+    case "spine-leaf":
+      centers = placeSpineLeaf(ast, links);
+      break;
+    case "manual":
+      centers = placeManual(ast);
+      break;
+    case "tiered":
+    default:
+      centers = placeBanded(ast, tieredRanks(ast, links));
+      break;
+  }
+  const boxes = ast.devices.map((d) => {
+    const fp = deviceFootprint(d);
+    const c = centers.get(d.id) ?? { x: 0, y: 0 };
+    return {
+      device: d,
+      cx: c.x,
+      cy: c.y,
+      x: c.x - fp.w / 2,
+      y: c.y - fp.h / 2,
+      w: fp.w,
+      h: fp.h,
+      band: 0
+    };
+  });
+  const boxById = new Map(boxes.map((b) => [b.device.id, b]));
+  const groupBoxesRaw = /* @__PURE__ */ new Map();
+  const depthOf = (id) => {
+    let depth = 0;
+    let g = ast.groups.find((x) => x.id === id);
+    while (g?.parent) {
+      depth++;
+      g = ast.groups.find((x) => x.id === g.parent);
+    }
+    return depth;
+  };
+  const groupsByDepth = [...ast.groups].sort((a, b) => depthOf(b.id) - depthOf(a.id));
+  for (const g of groupsByDepth) {
+    let l = Infinity, t = Infinity, r = -Infinity, bm = -Infinity;
+    const addBox = (e) => {
+      l = Math.min(l, e.left);
+      t = Math.min(t, e.top);
+      r = Math.max(r, e.right);
+      bm = Math.max(bm, e.bottom);
+    };
+    for (const mid of g.members) {
+      const mb = boxById.get(mid);
+      if (mb) addBox(effBox(mb));
+    }
+    for (const cid of g.children) {
+      const cb = groupBoxesRaw.get(cid);
+      if (cb) addBox(cb);
+    }
+    if (l === Infinity) continue;
+    const depth = depthOf(g.id);
+    const pad = NET_CONST.GROUP_PAD;
+    groupBoxesRaw.set(g.id, {
+      left: l - pad,
+      top: t - pad - NET_CONST.GROUP_HEADER,
+      right: r + pad,
+      bottom: bm + pad,
+      depth
+    });
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const b of boxes) {
+    const e = effBox(b);
+    minX = Math.min(minX, e.left);
+    minY = Math.min(minY, e.top);
+    maxX = Math.max(maxX, e.right);
+    maxY = Math.max(maxY, e.bottom);
+  }
+  for (const gb of groupBoxesRaw.values()) {
+    minX = Math.min(minX, gb.left);
+    minY = Math.min(minY, gb.top);
+    maxX = Math.max(maxX, gb.right);
+    maxY = Math.max(maxY, gb.bottom);
+  }
+  if (!Number.isFinite(minX)) {
+    minX = 0;
+    minY = 0;
+    maxX = NET_CONST.DEVICE_W;
+    maxY = NET_CONST.DEVICE_H;
+  }
+  const dx = NET_CONST.PAD - minX;
+  const dy = NET_CONST.PAD - minY;
+  for (const b of boxes) {
+    b.x += dx;
+    b.y += dy;
+    b.cx += dx;
+    b.cy += dy;
+  }
+  const groups = [];
+  for (const g of ast.groups) {
+    const gb = groupBoxesRaw.get(g.id);
+    if (!gb) continue;
+    groups.push({
+      group: g,
+      x: gb.left + dx,
+      y: gb.top + dy,
+      w: gb.right - gb.left,
+      h: gb.bottom - gb.top,
+      depth: gb.depth
+    });
+  }
+  const linkGeoms = links.map((link) => {
+    const a = boxById.get(link.from);
+    const b = boxById.get(link.to);
+    const p1 = edgePoint(a, b.cx, b.cy);
+    const p2 = edgePoint(b, a.cx, a.cy);
+    return {
+      link,
+      points: [p1, p2],
+      labelX: (p1.x + p2.x) / 2,
+      labelY: (p1.y + p2.y) / 2
+    };
+  });
+  const width = maxX - minX + 2 * NET_CONST.PAD;
+  const height = maxY - minY + 2 * NET_CONST.PAD;
+  return {
+    ast,
+    width: Math.max(width, 120),
+    height: Math.max(height, 80),
+    devices: boxes,
+    links: linkGeoms,
+    groups,
+    topologyClass: classify(ast),
+    warnings: ast.warnings,
+    title: ast.title
+  };
+}
+
+// src/diagrams/network/renderer.ts
+var r22 = (n) => Math.round(n * 100) / 100;
+function buildCss7(t) {
+  return `
+.sx-net { font-family: system-ui, -apple-system, sans-serif; }
+.sx-net-body { fill: ${t.deviceFill}; stroke: ${t.deviceStroke}; stroke-width: 2; }
+.sx-net-detail { fill: none; stroke: ${t.deviceStroke}; stroke-width: 1; }
+.sx-net-glyph { fill: ${t.deviceAccent}; stroke: none; }
+.sx-net-glyph-line { fill: none; stroke: ${t.deviceAccent}; stroke-width: 1.4; }
+.sx-net-icontext { font: 700 8px sans-serif; fill: ${t.deviceAccent}; }
+.sx-net-cloud-body { fill: ${t.cloudFill}; stroke: ${t.cloudStroke}; stroke-width: 2; }
+.sx-net-cloudtext { font: 600 13px sans-serif; fill: ${t.text}; }
+.sx-net-bus { stroke: ${t.deviceStroke}; stroke-width: 4; stroke-linecap: round; }
+.sx-net-label { font: 12px sans-serif; fill: ${t.label}; }
+.sx-net-sublabel { font: 10px sans-serif; fill: ${t.subLabel}; }
+.sx-net-link { fill: none; stroke-width: 2; }
+.sx-net-link-wireless, .sx-net-link-vpn { stroke-dasharray: 5 4; }
+.sx-net-link-lag { stroke-width: 3; }
+.sx-net-linklabel { font: 9px sans-serif; fill: ${t.linkLabel}; paint-order: stroke; stroke: ${t.bg}; stroke-width: 3px; stroke-linejoin: round; }
+.sx-net-port { font: 8px sans-serif; fill: ${t.linkLabel}; paint-order: stroke; stroke: ${t.bg}; stroke-width: 2.5px; stroke-linejoin: round; }
+.sx-net-boundary-site { fill: none; stroke: ${t.siteStroke}; stroke-width: 1.5; }
+.sx-net-boundary-rack { fill: none; stroke: ${t.siteStroke}; stroke-width: 1.5; stroke-dasharray: 1 2; }
+.sx-net-boundary-subnet, .sx-net-boundary-vlan { fill: ${t.subnetFill}; stroke: ${t.subnetStroke}; stroke-width: 1.2; stroke-dasharray: 5 3; }
+.sx-net-boundary-zone, .sx-net-boundary-dmz { fill: none; stroke: ${t.zoneStroke}; stroke-width: 1.2; stroke-dasharray: 5 3; }
+.sx-net-boundary-label { font: 600 10px sans-serif; }
+.sx-net-title { font: 700 16px sans-serif; fill: ${t.text}; }
+`.trim();
+}
+function linkColor(t, link) {
+  if (link.linkType === "copper" && link.vlans && link.vlans.length === 1) {
+    const vid = link.vlans[0];
+    const pal = t.vlanPalette.filter((c) => c !== t.negative);
+    const safe = pal.length ? pal : t.vlanPalette;
+    return safe[vid % safe.length];
+  }
+  switch (link.linkType) {
+    case "fiber":
+      return t.linkFiber;
+    case "wireless":
+      return t.linkWireless;
+    case "serial":
+      return t.linkSerial;
+    case "poe":
+      return t.linkPoe;
+    case "vpn":
+      return t.linkVpn;
+    case "lag":
+      return t.linkLag;
+    default:
+      return t.linkCopper;
+  }
 }
-function renderSentinel(s) {
-  return group({ class: "sx-pert-sentinel", "data-id": s.id }, [
-    circle({ cx: s.cx, cy: s.cy, r: s.r }),
-    text({ x: s.cx, y: s.cy + 3.5, "text-anchor": "middle" }, s.label)
-  ]);
+function annotation(link) {
+  const parts = [];
+  if (link.mode) parts.push(link.mode === "trunk" ? "Trunk" : "Access");
+  if (link.vlans?.length) parts.push(`VLAN ${link.vlans.join(",")}`);
+  if (link.speed) parts.push(link.speed);
+  if (link.linkType === "poe") parts.push("PoE");
+  if (link.linkType === "vpn") parts.push("VPN");
+  if (link.label) parts.push(link.label);
+  return parts.join(" \xB7 ");
+}
+function arrowHead(x1, y1, x2, y2, color, hs = 6) {
+  const ang = Math.atan2(y2 - y1, x2 - x1);
+  const a1 = ang + Math.PI - 0.45;
+  const a2 = ang + Math.PI + 0.45;
+  return polygon({
+    fill: color,
+    points: `${r22(x2)},${r22(y2)} ${r22(x2 + hs * Math.cos(a1))},${r22(y2 + hs * Math.sin(a1))} ${r22(x2 + hs * Math.cos(a2))},${r22(y2 + hs * Math.sin(a2))}`
+  });
 }
-function renderAxis2(axis, gridTop) {
+function renderLink(lg, t) {
+  const { link } = lg;
+  const p1 = lg.points[0];
+  const p2 = lg.points[lg.points.length - 1];
+  const color = linkColor(t, link);
+  const cls = `sx-net-link sx-net-link-${link.linkType}`;
   const parts = [];
-  for (const tk of axis.ticks) {
-    if (tk.major) {
-      parts.push(line({ class: "sx-pert-grid", x1: tk.pos, y1: gridTop, x2: tk.pos, y2: axis.baseline }));
-    }
+  if (link.linkType === "lag") {
+    const ang = Math.atan2(p2.y - p1.y, p2.x - p1.x) + Math.PI / 2;
+    const ox = 1.8 * Math.cos(ang);
+    const oy = 1.8 * Math.sin(ang);
+    parts.push(line({ class: cls, stroke: color, x1: r22(p1.x + ox), y1: r22(p1.y + oy), x2: r22(p2.x + ox), y2: r22(p2.y + oy) }));
+    parts.push(line({ class: cls, stroke: color, x1: r22(p1.x - ox), y1: r22(p1.y - oy), x2: r22(p2.x - ox), y2: r22(p2.y - oy) }));
+  } else {
+    parts.push(el("polyline", { class: cls, stroke: color, points: lg.points.map((p) => `${r22(p.x)},${r22(p.y)}`).join(" ") }));
   }
-  parts.push(line({ class: "baseline", x1: axis.start, y1: axis.baseline, x2: axis.end, y2: axis.baseline }));
-  for (const tk of axis.ticks) {
-    const len = tk.major ? 7 : 4;
-    parts.push(line({ x1: tk.pos, y1: axis.baseline, x2: tk.pos, y2: axis.baseline + len }));
-    if (tk.major) {
-      parts.push(
-        text({ x: tk.pos, y: axis.baseline + 18, "text-anchor": "middle" }, fmtVal(tk.value))
-      );
+  if (link.directed) parts.push(arrowHead(p1.x, p1.y, p2.x, p2.y, color));
+  if (link.linkType === "fiber") {
+    const ang = Math.atan2(p2.y - p1.y, p2.x - p1.x) + Math.PI / 2;
+    for (const f of [0.4, 0.55]) {
+      const mx = p1.x + (p2.x - p1.x) * f;
+      const my = p1.y + (p2.y - p1.y) * f;
+      parts.push(line({ class: cls, stroke: color, x1: r22(mx - 3 * Math.cos(ang)), y1: r22(my - 3 * Math.sin(ang)), x2: r22(mx + 3 * Math.cos(ang)), y2: r22(my + 3 * Math.sin(ang)) }));
     }
   }
-  return group({ class: "sx-pert-axis" }, parts);
+  const ann = annotation(link);
+  if (ann) parts.push(text({ class: "sx-net-linklabel", x: r22(lg.labelX), y: r22(lg.labelY - 3), "text-anchor": "middle" }, ann));
+  if (link.portNear) parts.push(text({ class: "sx-net-port", x: r22(p1.x + (p2.x - p1.x) * 0.16), y: r22(p1.y + (p2.y - p1.y) * 0.16 - 3), "text-anchor": "middle" }, link.portNear));
+  if (link.portFar) parts.push(text({ class: "sx-net-port", x: r22(p2.x + (p1.x - p2.x) * 0.16), y: r22(p2.y + (p1.y - p2.y) * 0.16 - 3), "text-anchor": "middle" }, link.portFar));
+  return group(
+    {
+      class: "sx-net-link-g",
+      "data-from": link.from,
+      "data-to": link.to,
+      "data-type": link.linkType,
+      ...link.vlans?.length ? { "data-vlan": link.vlans.join(",") } : {},
+      ...link.speed ? { "data-speed": link.speed } : {},
+      ...link.mode ? { "data-mode": link.mode } : {}
+    },
+    parts
+  );
 }
-function renderAoa(aoa) {
-  const arcEls = [];
-  const labelEls = [];
-  for (const a of aoa.arcs) {
-    const cls = `sx-pert-aoa-arc${a.dummy ? " dummy" : ""}${a.critical ? " critical" : ""}`;
-    const marker = a.critical ? "url(#sx-pert-arrow-crit)" : "url(#sx-pert-arrow)";
-    arcEls.push(
-      path({
-        class: cls,
-        d: a.d,
-        "marker-end": marker,
-        "data-from": a.from,
-        "data-to": a.to,
-        "data-task": a.taskId ?? "",
-        "data-dummy": String(a.dummy),
-        "data-critical": String(a.critical)
-      })
-    );
-    if (!a.dummy && a.label) {
-      const critCls = a.critical ? " critical" : "";
-      const durStr = fmtVal(a.duration ?? 0);
-      const w = Math.max(a.label.length * 6.2, durStr.length * 6) + 8;
-      labelEls.push(
-        rect({ class: "sx-pert-edge-halo", x: a.labelX - w / 2, y: a.labelY - 16, width: w, height: 31, rx: 3, ry: 3 })
-      );
-      labelEls.push(
-        text({ class: `sx-pert-aoa-name${critCls}`, x: a.labelX, y: a.labelY - 4, "text-anchor": "middle" }, a.label)
-      );
-      labelEls.push(
-        text({ class: `sx-pert-aoa-dur${critCls}`, x: a.labelX, y: a.labelY + 12, "text-anchor": "middle" }, durStr)
-      );
-    }
-  }
-  const eventEls = [];
-  for (const e of aoa.events) {
-    eventEls.push(
-      group({ class: `sx-pert-aoa-event${e.critical ? " critical" : ""}`, "data-event": e.id }, [
-        circle({ cx: e.x, cy: e.y, r: e.r }),
-        text({ x: e.x, y: e.y + 4.5, "text-anchor": "middle" }, String(e.id))
-      ])
-    );
-  }
-  return group({ class: "sx-pert-aoa" }, [
-    group({ class: "sx-pert-aoa-arcs" }, arcEls),
-    group({ class: "sx-pert-aoa-labels" }, labelEls),
-    group({ class: "sx-pert-aoa-events" }, eventEls)
-  ]);
+function renderGroup(gb, t) {
+  const k = gb.group.kind;
+  const cls = `sx-net-boundary-${k}`;
+  const labelColor = k === "zone" || k === "dmz" ? t.zoneStroke : k === "subnet" || k === "vlan" ? t.subnetStroke : t.siteStroke;
+  const label = gb.group.label ?? gb.group.id;
+  const tag = k === "vlan" ? `VLAN ${label}` : label;
+  return group(
+    { class: "sx-net-boundary", "data-kind": k, "data-label": escapeXml(label) },
+    [
+      rect({ class: cls, x: r22(gb.x), y: r22(gb.y), width: r22(gb.w), height: r22(gb.h), rx: 8, ry: 8 }),
+      text({ class: "sx-net-boundary-label", fill: labelColor, x: r22(gb.x + NET_CONST.GROUP_LABEL_INSET), y: r22(gb.y + 13) }, tag)
+    ]
+  );
 }
-function summaryText(summary) {
-  const u = unitWord(summary.unit);
-  const dur = `${fmtVal(summary.projectDuration)}${u ? " " + u : ""}`;
-  const sigma = summary.projectStdDev !== void 0 ? ` \xB7 \u03C3 \u2248 ${fmtVal(summary.projectStdDev)}` : "";
-  const plain = `Project duration ${dur} \xB7 ${summary.taskCount} tasks \xB7 ${summary.depCount} dependencies \xB7 ${summary.criticalCount} critical${sigma}`;
-  const critPath = summary.criticalPath.map((id) => id).join(" \u2192 ");
-  return { plain, critPath };
+function renderDevice(b, t) {
+  const d = b.device;
+  const parts = [drawDeviceIcon(d, { x: b.x, y: b.y, w: b.w, h: b.h })];
+  if (!isCloudKind(d.kind)) {
+    const labelY = b.y + b.h + NET_CONST.LABEL_GAP + 11;
+    parts.push(text({ class: "sx-net-label", x: r22(b.cx), y: r22(labelY), "text-anchor": "middle" }, d.label ?? d.id));
+    const sub = d.ip ?? d.model;
+    if (sub) parts.push(text({ class: "sx-net-sublabel", x: r22(b.cx), y: r22(labelY + NET_CONST.SUBLABEL_H), "text-anchor": "middle" }, sub));
+  }
+  const attrs = {
+    class: "sx-net-device",
+    "data-id": d.id,
+    "data-kind": d.kind
+  };
+  if (d.tier) attrs["data-tier"] = d.tier;
+  if (d.ip) attrs["data-ip"] = d.ip;
+  if (d.cameraType) attrs["data-type"] = d.cameraType;
+  return group(attrs, parts);
 }
-function renderPertLayout(layout, config) {
-  const t = resolveBaseTheme(config?.theme ?? "default");
+function renderNetworkLayout(layout, config) {
+  const t = resolveNetworkTheme(config?.theme ?? "default");
   const children = [];
-  const cp = layout.summary.criticalPath;
-  children.push(title(`PERT network${layout.title ? " \u2014 " + layout.title : ""}`));
-  children.push(
-    desc(
-      `${layout.summary.taskCount} activities, project duration ${fmtVal(layout.summary.projectDuration)} ${unitWord(layout.unit)}` + (cp.length ? `, critical path ${cp.join(" \u2192 ")}` : "") + "."
-    )
-  );
-  children.push(el("style", {}, buildCss4(t)));
-  children.push(markers2());
+  const counts = /* @__PURE__ */ new Map();
+  for (const b of layout.devices) counts.set(b.device.kind, (counts.get(b.device.kind) ?? 0) + 1);
+  const linkTypes = /* @__PURE__ */ new Map();
+  for (const l of layout.links) linkTypes.set(l.link.linkType, (linkTypes.get(l.link.linkType) ?? 0) + 1);
+  const descParts = [
+    `${layout.devices.length} devices, ${layout.links.length} links, ${layout.groups.length} boundaries.`,
+    `Topology: ${layout.topologyClass}.`,
+    linkTypes.size ? `Links: ${[...linkTypes].map(([k, n]) => `${n} ${k}`).join(", ")}.` : "",
+    layout.warnings.length ? `Warnings: ${layout.warnings.join("; ")}.` : ""
+  ].filter(Boolean);
+  children.push(title(`Network diagram${layout.title ? " \u2014 " + layout.title : ""}`));
+  children.push(desc(descParts.join(" ")));
+  children.push(el("style", {}, buildCss7(t)));
+  const titleBand = layout.title ? 30 : 0;
   if (layout.title) {
-    children.push(
-      text({ x: layout.width / 2, y: 26, class: "sx-pert-title", "text-anchor": "middle" }, layout.title)
-    );
-  }
-  if (layout.aoa) {
-    children.push(renderAoa(layout.aoa));
-  } else {
-    if (layout.lanes && layout.lanes.length) {
-      children.push(renderLanes(layout.lanes, layout.width));
-    }
-    if (layout.axis) {
-      let minBoxY = Infinity;
-      for (const b of layout.boxes) minBoxY = Math.min(minBoxY, b.y);
-      children.push(renderAxis2(layout.axis, isFinite(minBoxY) ? minBoxY : layout.axis.baseline - 20));
-    }
-    const edgeEls = [];
-    for (const e of layout.edges) edgeEls.push(renderEdge3(e));
-    children.push(group({ class: "sx-pert-edges" }, edgeEls));
-    if (layout.sentinels.length) {
-      children.push(group({ class: "sx-pert-sentinels" }, layout.sentinels.map(renderSentinel)));
-    }
-    const boxEls = [];
-    for (const b of layout.boxes) boxEls.push(renderBox2(b, layout.mode));
-    children.push(group({ class: "sx-pert-tasks" }, boxEls));
-    const labelEls = [];
-    for (const e of layout.edges) {
-      const lbl = renderEdgeLabel2(e);
-      if (lbl) labelEls.push(lbl);
-    }
-    children.push(group({ class: "sx-pert-labels" }, labelEls));
+    children.push(text({ x: r22(layout.width / 2), y: 21, class: "sx-net-title", "text-anchor": "middle" }, layout.title));
   }
-  const { plain, critPath } = summaryText(layout.summary);
-  const footerY = layout.height - 12;
-  const footerParts = [
-    text({ class: "sx-pert-summary", x: PERT_PAD, y: footerY, "text-anchor": "start" }, plain)
-  ];
-  if (critPath) {
-    footerParts.push(
-      text(
-        { class: "sx-pert-summary crit", x: layout.width - PERT_PAD, y: footerY, "text-anchor": "end" },
-        `Critical path: ${critPath}`
-      )
-    );
-  }
-  children.push(group({ class: "sx-pert-footer" }, footerParts));
+  const body = [];
+  const sortedGroups = [...layout.groups].sort((a, b) => a.depth - b.depth);
+  body.push(group({ class: "sx-net-boundaries" }, sortedGroups.map((g) => renderGroup(g, t))));
+  body.push(group({ class: "sx-net-links" }, layout.links.map((l) => renderLink(l, t))));
+  body.push(group({ class: "sx-net-devices" }, layout.devices.map((b) => renderDevice(b))));
+  children.push(titleBand ? group({ transform: `translate(0, ${titleBand})` }, body) : group({}, body));
+  const height = layout.height + titleBand;
   return svgRoot(
     {
-      class: "sx-pert",
+      class: "sx-net",
       role: "img",
-      "aria-label": escapeXml(layout.title ?? "PERT network diagram"),
-      width: layout.width,
-      height: layout.height,
-      viewBox: `0 0 ${layout.width} ${layout.height}`,
-      "data-diagram-type": "pert"
+      "aria-label": escapeXml(layout.title ?? "Network diagram"),
+      width: r22(layout.width),
+      height: r22(height),
+      viewBox: `0 0 ${r22(layout.width)} ${r22(height)}`,
+      "data-diagram-type": "network"
     },
     children
   );
 }
-var PERT_PAD = 24;
-function renderPert(textOrAst, config) {
-  const ast = typeof textOrAst === "string" ? parsePert(textOrAst) : textOrAst;
-  const schedule = schedulePert(ast);
-  const layout = layoutPert(ast, schedule);
-  return renderPertLayout(layout, config);
+function renderNetwork(textOrAst, config) {
+  const ast = typeof textOrAst === "string" ? parseNetwork(textOrAst) : textOrAst;
+  const layout = layoutNetwork2(ast);
+  return renderNetworkLayout(layout, config);
 }
 
-// src/diagrams/pert/index.ts
-var pert = {
-  type: "pert",
+// src/diagrams/network/index.ts
+var network = {
+  type: "network",
   detect(text2) {
     for (const raw of text2.split(/\r?\n/)) {
       const t = raw.trim();
       if (!t) continue;
       if (t.startsWith("#") || t.startsWith("//")) continue;
-      return /^pert\b/i.test(t);
+      return /^(network|topology)\b/i.test(t);
     }
     return false;
   },
-  parse: parsePert,
+  parse: parseNetwork,
   render(text2, config) {
-    return renderPert(text2, config);
+    return renderNetwork(text2, config);
   }
 };
 
+// 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 +14988,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);
@@ -11255,11 +15009,11 @@ function readQuoted2(line2, from) {
 function parseAxis(raw) {
   const arrowMatch = raw.match(/\s*(→|↑|->|>|↓|←|<-|<)\s*/);
   if (arrowMatch) {
-    const arrow = arrowMatch[1];
+    const arrow2 = arrowMatch[1];
     const idx = arrowMatch.index;
     const left = raw.slice(0, idx).trim();
     const right = raw.slice(idx + arrowMatch[0].length).trim();
-    const reversed = arrow === "\u2190" || arrow === "<-" || arrow === "<";
+    const reversed = arrow2 === "\u2190" || arrow2 === "<-" || arrow2 === "<";
     if (reversed) {
       return { low: right, high: left, reversed: true };
     }
@@ -11270,7 +15024,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 +15139,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 +15151,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 +15159,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 +15201,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 +15286,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;
@@ -11574,11 +15328,11 @@ var CANVAS_W = 720;
 var CANVAS_H = 560;
 var PADDING_X = 110;
 var PADDING_Y = 90;
-var CHAR_W = 6.2;
+var CHAR_W2 = 6.2;
 var LABEL_H = 14;
 function estimateWidth(text2) {
   const cjk = (text2.match(/[\u3000-\u9fff]/g) ?? []).length;
-  return (text2.length - cjk) * CHAR_W + cjk * 12 + 8;
+  return (text2.length - cjk) * CHAR_W2 + cjk * 12 + 8;
 }
 function clamp01(v) {
   return Math.max(0.02, Math.min(0.98, v));
@@ -12629,7 +16383,7 @@ var ErdParseError = class extends Error {
   }
   lineNumber;
 };
-function stripComment2(s) {
+function stripComment3(s) {
   let out = "";
   let inQuote = false;
   for (let i = 0; i < s.length; i++) {
@@ -12683,7 +16437,7 @@ function parseCardToken(raw, side) {
 }
 function lex(text2) {
   return text2.split(/\r?\n/).map((raw, i) => ({
-    text: stripComment2(raw).trim(),
+    text: stripComment3(raw).trim(),
     lineNumber: i + 1
   })).filter((l) => l.text.length > 0);
 }
@@ -13334,7 +17088,7 @@ function sideAnchor(e, side, col) {
 }
 
 // src/diagrams/erd/renderer.ts
-function buildCss5(t) {
+function buildCss8(t) {
   return `
 .lt-erd { font-family: system-ui, -apple-system, sans-serif; }
 .lt-erd-title { font: bold 16px sans-serif; fill: ${t.text}; }
@@ -13420,10 +17174,10 @@ function renderEntity(e) {
         a.name
       )
     );
-    const markers3 = attrMarkers(a);
+    const markers5 = attrMarkers(a);
     const markerW = 26;
     const markerGap = 4;
-    const markersBlockW = markers3.length * markerW + (markers3.length - 1) * markerGap;
+    const markersBlockW = markers5.length * markerW + (markers5.length - 1) * markerGap;
     const markersStartX = e.x + e.width - C2.ENTITY_PADDING_X - markersBlockW;
     if (a.type) {
       body.push(
@@ -13438,8 +17192,8 @@ function renderEntity(e) {
         )
       );
     }
-    for (let j = 0; j < markers3.length; j++) {
-      const m = markers3[j];
+    for (let j = 0; j < markers5.length; j++) {
+      const m = markers5[j];
       const px = markersStartX + j * (markerW + markerGap);
       body.push(
         rect({
@@ -13644,7 +17398,7 @@ function renderEdge4(edge) {
 function renderErdAst(result, themeName = "default") {
   const theme = resolveBaseTheme(themeName);
   const { entities, edges, width, height, ast } = result;
-  const cssBlock = el("style", {}, buildCss5(theme));
+  const cssBlock = el("style", {}, buildCss8(theme));
   const titleNode = title(ast.title ?? "Schematex ERD");
   const descNode = desc(
     `Entity-Relationship Diagram with ${entities.length} entities and ${edges.length} relationships.`
@@ -13711,7 +17465,7 @@ var BreadboardParseError = class extends Error {
   }
   lineNumber;
 };
-function stripComment3(s) {
+function stripComment4(s) {
   let out = "";
   let inQuote = false;
   for (let i = 0; i < s.length; i++) {
@@ -13732,7 +17486,7 @@ function unquote6(v) {
 }
 function lex2(text2) {
   return text2.split(/\r?\n/).map((raw, i) => ({
-    text: stripComment3(raw).trimEnd().replace(/^\s+/, ""),
+    text: stripComment4(raw).trimEnd().replace(/^\s+/, ""),
     lineNumber: i + 1
   })).filter((l) => l.text.length > 0);
 }
@@ -13779,7 +17533,7 @@ function parsePlacement(rest, lineNumber) {
   }
   return { kind: "point", at: parseCoord(body, lineNumber) };
 }
-var KIND_ALIASES = {
+var KIND_ALIASES2 = {
   resistor: "resistor",
   led: "led",
   cap: "cap-elec",
@@ -13844,7 +17598,7 @@ function resolveKind(tokens, lineNumber) {
     if (!ACTUATOR_SUBTYPES[sub]) throw new BreadboardParseError(`Unknown actuator subtype '${sub}'`, lineNumber);
     return { kind: ACTUATOR_SUBTYPES[sub], consumed: 2 };
   }
-  if (KIND_ALIASES[head]) return { kind: KIND_ALIASES[head], consumed: 1 };
+  if (KIND_ALIASES2[head]) return { kind: KIND_ALIASES2[head], consumed: 1 };
   throw new BreadboardParseError(`Unknown part kind '${head}'`, lineNumber);
 }
 function parsePart(rawLine, lineNumber) {
@@ -14714,7 +18468,7 @@ var WIRE_COLOR_MAP = {
   brown: "#78350f",
   grey: "#64748b"
 };
-function buildCss6(t) {
+function buildCss9(t) {
   return `
 .lt-bb { font-family: system-ui, -apple-system, sans-serif; }
 .lt-bb-title { font: 600 16px sans-serif; fill: ${t.text}; }
@@ -14828,12 +18582,12 @@ function renderSubstrate(sub) {
 function renderPart(lp) {
   const spec = partSpec(lp.part.kind, lp.part.args);
   const body = spec.body(lp.part, lp.width, lp.height);
-  const labelText = lp.part.label ?? defaultPartLabel(lp);
-  const labelEl = labelText ? text({
+  const labelText2 = lp.part.label ?? defaultPartLabel(lp);
+  const labelEl = labelText2 ? text({
     x: lp.x + lp.width / 2,
     y: spec.category === "side" ? lp.y - 6 : lp.y - 4,
     class: "lt-bb-part-label"
-  }, labelText) : "";
+  }, labelText2) : "";
   return group(
     { class: `lt-bb-part lt-bb-part-${lp.part.kind}`, transform: `translate(${lp.x.toFixed(2)} ${lp.y.toFixed(2)})` },
     [body]
@@ -14862,7 +18616,7 @@ function renderWire(lw) {
 }
 function renderBreadboardLayout(layout, config) {
   const theme = resolveBaseTheme(config?.theme ?? "default");
-  const css = buildCss6(theme);
+  const css = buildCss9(theme);
   const titleStr = layout.ast.title ?? "Breadboard";
   const titleNode = layout.ast.title ? text({ x: BB_CONST.MARGIN, y: 22, class: "lt-bb-title" }, layout.ast.title) : "";
   const substrate = renderSubstrate(layout.substrate);
@@ -17060,13 +20814,13 @@ function parseFbd(text2) {
       parseStatement(state2, stmt);
       i++;
     }
-    const network = {
+    const network2 = {
       index: idx,
       blocks: state2.blocks.slice(blocksBefore),
       wires: state2.wires.slice(wiresBefore)
     };
-    if (nh.title !== void 0) network.title = nh.title;
-    networks.push(network);
+    if (nh.title !== void 0) network2.title = nh.title;
+    networks.push(network2);
   }
   for (const block of state2.blocks) {
     if (!block.instance) continue;
@@ -17205,18 +20959,18 @@ function makePort(p, side, edgeX, x, y) {
   if (p.negated) port.negated = true;
   return port;
 }
-function buildGraph2(network) {
+function buildGraph2(network2) {
   const incoming = /* @__PURE__ */ new Map();
   const outgoing = /* @__PURE__ */ new Map();
   const inputVars = /* @__PURE__ */ new Map();
   const outputVars = /* @__PURE__ */ new Map();
-  for (const b of network.blocks) {
+  for (const b of network2.blocks) {
     incoming.set(b.id, /* @__PURE__ */ new Set());
     outgoing.set(b.id, /* @__PURE__ */ new Set());
     inputVars.set(b.id, /* @__PURE__ */ new Set());
     outputVars.set(b.id, /* @__PURE__ */ new Set());
   }
-  for (const w of network.wires) {
+  for (const w of network2.wires) {
     if (w.from.kind === "port" && w.to.kind === "port") {
       incoming.get(w.to.blockId)?.add(w.from.blockId);
       outgoing.get(w.from.blockId)?.add(w.to.blockId);
@@ -17228,7 +20982,7 @@ function buildGraph2(network) {
   }
   return { incoming, outgoing, inputVars, outputVars };
 }
-function assignLayers(network, graph) {
+function assignLayers(network2, graph) {
   const layer = /* @__PURE__ */ new Map();
   const visiting = /* @__PURE__ */ new Set();
   const visit = (id) => {
@@ -17245,20 +20999,20 @@ function assignLayers(network, graph) {
     layer.set(id, max);
     return max;
   };
-  for (const b of network.blocks) visit(b.id);
+  for (const b of network2.blocks) visit(b.id);
   return layer;
 }
-function layoutNetwork2(network, originX, originY) {
-  const graph = buildGraph2(network);
+function layoutNetwork3(network2, originX, originY) {
+  const graph = buildGraph2(network2);
   const sizes = /* @__PURE__ */ new Map();
-  for (const b of network.blocks) sizes.set(b.id, computeBlockSize(b));
-  const layerOf = assignLayers(network, graph);
+  for (const b of network2.blocks) sizes.set(b.id, computeBlockSize(b));
+  const layerOf = assignLayers(network2, graph);
   const maxLayer = Math.max(0, ...Array.from(layerOf.values()));
   const byLayer = Array.from({ length: maxLayer + 1 }, () => []);
-  for (const b of network.blocks) byLayer[layerOf.get(b.id)].push(b.id);
+  for (const b of network2.blocks) byLayer[layerOf.get(b.id)].push(b.id);
   const inputVarsAll = /* @__PURE__ */ new Set();
   const outputVarsAll = /* @__PURE__ */ new Set();
-  for (const b of network.blocks) {
+  for (const b of network2.blocks) {
     for (const v of graph.inputVars.get(b.id) ?? []) inputVarsAll.add(v);
     for (const v of graph.outputVars.get(b.id) ?? []) outputVarsAll.add(v);
   }
@@ -17291,7 +21045,7 @@ function layoutNetwork2(network, originX, originY) {
     yMax = Math.max(yMax, y);
   }
   const layoutBlocks = [];
-  for (const b of network.blocks) {
+  for (const b of network2.blocks) {
     const bb = blockBboxes.get(b.id);
     layoutBlocks.push({
       block: b,
@@ -17339,7 +21093,7 @@ function layoutNetwork2(network, originX, originY) {
   const wires = [];
   const junctions = [];
   const fanOutCounts = /* @__PURE__ */ new Map();
-  for (const w of network.wires) {
+  for (const w of network2.wires) {
     if (w.from.kind === "port") {
       const key = `${w.from.blockId}.${w.from.portName}`;
       fanOutCounts.set(key, (fanOutCounts.get(key) ?? 0) + 1);
@@ -17357,7 +21111,7 @@ function layoutNetwork2(network, originX, originY) {
   const varTermByName = /* @__PURE__ */ new Map();
   for (const t of varTerms) varTermByName.set(t.name, t);
   const colCursor = /* @__PURE__ */ new Map();
-  for (const w of network.wires) {
+  for (const w of network2.wires) {
     const path2 = routeWire(w, portByKey, varTermByName, colCursor, layerX, layerWidths);
     if (path2) {
       wires.push({ wire: w, path: path2 });
@@ -17382,7 +21136,7 @@ function layoutNetwork2(network, originX, originY) {
     FBD_CONST.block_min_height + FBD_CONST.network_label_h + FBD_CONST.network_padding_y * 2
   );
   return {
-    network,
+    network: network2,
     x: originX,
     y: originY,
     width,
@@ -17443,7 +21197,7 @@ function layoutFbd(ast) {
   let cursorY = 0;
   let maxWidth = 0;
   for (const net of ast.networks) {
-    const ln = layoutNetwork2(net, 0, cursorY);
+    const ln = layoutNetwork3(net, 0, cursorY);
     networks.push(ln);
     cursorY = ln.y + ln.height + FBD_CONST.network_gap_y;
     maxWidth = Math.max(maxWidth, ln.width);
@@ -17593,7 +21347,7 @@ function renderBlock(lb) {
     parts
   );
 }
-function renderNetwork(ln) {
+function renderNetwork2(ln) {
   const parts = [];
   parts.push(rect({
     class: "lt-fbd-network-frame",
@@ -17659,7 +21413,7 @@ function renderFbdLayout(layout) {
   const descEl = desc(`FBD with ${layout.networks.length} network(s).`);
   const root = group(
     { transform: `translate(${margin},${margin})` },
-    layout.networks.map(renderNetwork)
+    layout.networks.map(renderNetwork2)
   );
   return svgRoot(
     {
@@ -18644,7 +22398,10 @@ var plugins = [
   sfc,
   prisma,
   usecase,
-  pert
+  pert,
+  sequence,
+  petri,
+  network
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -18655,7 +22412,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', 'sequence', 'petri', or 'network'."
   );
 }
 function preprocess8(text2) {
@@ -18680,9 +22437,80 @@ 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.`
+      );
+    }
+    const ast = plugin.parse(prepared);
+    const diagnostics = runLint(plugin, prepared);
+    return {
+      ok: true,
+      status: diagnostics.length > 0 ? "partial" : "valid",
+      type: plugin.type,
+      ast,
+      diagnostics
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: "invalid",
+      type: plugin?.type ?? config?.type ?? null,
+      diagnostics: [diagnosticFromError(err)]
+    };
+  }
+}
+function runLint(plugin, prepared) {
+  if (!plugin.lint) return [];
+  try {
+    return plugin.lint(prepared);
+  } catch {
+    return [];
+  }
+}
 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);
+    const svg = renderWithPlugin(prepared, plugin, config);
+    const diagnostics = runLint(plugin, prepared);
+    return {
+      ok: true,
+      status: diagnostics.length > 0 ? "partial" : "valid",
+      type: plugin.type,
+      svg,
+      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 +22520,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 { GEOMETRY, decisiontree, drawDeviceIcon, iconSize, network, parse, parseResult, pert, petri, pid, prisma, render, renderEquip, renderPreview, renderResult, sequence, state, timeline, usecase };
+//# sourceMappingURL=chunk-7AFW2J6J.js.map
+//# sourceMappingURL=chunk-7AFW2J6J.js.map