schematex 0.2.4 → 0.3.0

package/dist/{chunk-VPKCW4PB.js → chunk-NNU4RGT3.js}

@@ -1,14 +1,14 @@
 import { orgchart } from './chunk-FCGHV6ZK.js';
-import { circuit } from './chunk-PGALHQFF.js';
+import { circuit } from './chunk-XZNPAD6E.js';
 import { blockdiagram } from './chunk-UGCUNADI.js';
 import { ladder } from './chunk-U6L3FAML.js';
 import { sld } from './chunk-FE6GAUNW.js';
 import { entity } from './chunk-M5B2UUNW.js';
 import { fishbone } from './chunk-ZNDIGQJD.js';
 import { venn } from './chunk-JDTB7IKL.js';
-import { flowchart } from './chunk-J2LVOWVY.js';
+import { flowchart, layoutFlowchart } from './chunk-TYCHEOQX.js';
 import { genogram } from './chunk-H2OEUBPO.js';
-import { ecomap } from './chunk-LR4X4ZRG.js';
+import { ecomap } from './chunk-NB56L5QK.js';
 import { pedigree } from './chunk-OC22GGQN.js';
 import { phylo } from './chunk-YQANC7HQ.js';
 import { sociogram } from './chunk-RP5UATRA.js';
@@ -621,7 +621,7 @@ function layoutDecisionTree(ast) {
   enforceSibGap(root, sibH, sibGap);
   const levelOffsets = computeLevelOffsets(root, sibH, levelGap);
   setFinal(root, sibH, levelOffsets);
-  const PADDING2 = 40;
+  const PADDING3 = 40;
   const extraLeft = ast.mode === "decision" && !sibH ? 110 : 0;
   let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
   for (const n of all) {
@@ -646,8 +646,8 @@ function layoutDecisionTree(ast) {
       maxX = Math.max(maxX, n.xFinal + n.size.w / 2);
     }
   }
-  const offsetX = PADDING2 + extraLeft - minX;
-  const offsetY = PADDING2 - minY;
+  const offsetX = PADDING3 + extraLeft - minX;
+  const offsetY = PADDING3 - minY;
   const layoutNodes = all.map((w) => ({
     node: w.node,
     x: w.xFinal + offsetX,
@@ -708,8 +708,8 @@ function layoutDecisionTree(ast) {
     for (const n of layoutNodes) if (n.node.kind === "end") endX = Math.max(endX, n.x + n.width / 2);
     payoffColumnX = endX + payoffColGap;
   }
-  const width = Math.ceil(maxX - minX + PADDING2 * 2 + extraRight + extraLeft);
-  const height = Math.ceil(maxY - minY + PADDING2 * 2);
+  const width = Math.ceil(maxX - minX + PADDING3 * 2 + extraRight + extraLeft);
+  const height = Math.ceil(maxY - minY + PADDING3 * 2);
   return {
     width,
     height,
@@ -2626,6 +2626,2804 @@ var timeline = {
   }
 };
 
+// src/diagrams/state/parser.ts
+var StateParseError = class extends Error {
+  constructor(message, line2) {
+    super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
+    this.line = line2;
+    this.name = "StateParseError";
+  }
+  line;
+};
+var PSEUDO_KEYWORDS = {
+  initial: "initial",
+  final: "final",
+  choice: "choice",
+  junction: "junction",
+  fork: "fork",
+  join: "join",
+  history: "history",
+  dhistory: "dhistory",
+  terminate: "terminate",
+  entry_point: "entry_point",
+  exit_point: "exit_point"
+};
+var MERMAID_STEREOTYPE = {
+  choice: "choice",
+  fork: "fork",
+  join: "join",
+  end: "final"
+};
+function preprocess3(src) {
+  const out = [];
+  const lines = src.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("#") || trimmed.startsWith("//") || trimmed.startsWith("%%")) continue;
+    const indent = raw.length - raw.replace(/^\s+/, "").length;
+    out.push({ indent, text: trimmed, line: i + 1 });
+  }
+  return out;
+}
+function unquote2(s) {
+  if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+function parseProps(s) {
+  const out = {};
+  const inner = s.replace(/^\[/, "").replace(/\]$/, "");
+  if (!inner.trim()) return out;
+  for (const part of inner.split(",")) {
+    const idx = part.indexOf(":");
+    if (idx < 0) continue;
+    out[part.slice(0, idx).trim()] = unquote2(part.slice(idx + 1).trim());
+  }
+  return out;
+}
+function parseTransitionLabel(label) {
+  const out = {};
+  let rest = label.trim();
+  if (!rest) return out;
+  let depth = 0;
+  let slashIdx = -1;
+  for (let i = 0; i < rest.length; i++) {
+    const c = rest[i];
+    if (c === "[") depth++;
+    else if (c === "]") depth--;
+    else if (c === "/" && depth === 0) {
+      slashIdx = i;
+      break;
+    }
+  }
+  if (slashIdx >= 0) {
+    out.action = rest.slice(slashIdx + 1).trim();
+    rest = rest.slice(0, slashIdx).trim();
+  }
+  const gMatch = rest.match(/^(?<trig>[^[]*?)\s*\[(?<guard>[^\]]*)\]\s*$/);
+  if (gMatch?.groups) {
+    out.guard = gMatch.groups.guard.trim();
+    const trig = gMatch.groups.trig.trim();
+    if (trig) out.trigger = trig;
+  } else if (rest.length) {
+    out.trigger = rest;
+  }
+  return out;
+}
+function parseActivityLine(text2) {
+  const match = text2.match(/^(entry|exit|do)\s*\/\s*(.*)$/);
+  if (match) {
+    return { kind: match[1], action: match[2].trim() };
+  }
+  const parsed = parseTransitionLabel(text2);
+  if (!parsed.trigger && !parsed.guard && !parsed.action) return void 0;
+  return {
+    kind: "internal",
+    trigger: parsed.trigger,
+    guard: parsed.guard,
+    action: parsed.action
+  };
+}
+function newPseudoId(ctx, kind) {
+  ctx.pseudoCounter += 1;
+  return `__${kind}_${ctx.pseudoCounter}`;
+}
+function ensureInitialAlias(ctx, parent) {
+  if (!parent) {
+    if (ctx.initialAlias) {
+      const existing = ctx.byId.get(ctx.initialAlias);
+      if (existing) return existing;
+    }
+    const node2 = {
+      id: newPseudoId(ctx, "initial"),
+      label: "",
+      kind: "pseudo",
+      pseudoKind: "initial",
+      activities: [],
+      children: []
+    };
+    ctx.initialAlias = node2.id;
+    ctx.byId.set(node2.id, node2);
+    ctx.states.push(node2);
+    return node2;
+  }
+  for (const child of parent.children) {
+    if (child.id.startsWith("__initial_") && child.label === "") return child;
+  }
+  const node = {
+    id: newPseudoId(ctx, "initial"),
+    label: "",
+    kind: "pseudo",
+    pseudoKind: "initial",
+    activities: [],
+    children: [],
+    parent: parent.id
+  };
+  ctx.byId.set(node.id, node);
+  parent.children.push(node);
+  return node;
+}
+function ensureFinalAlias(ctx, parent) {
+  if (!parent) {
+    if (ctx.finalAlias) {
+      const existing = ctx.byId.get(ctx.finalAlias);
+      if (existing) return existing;
+    }
+    const node2 = {
+      id: newPseudoId(ctx, "final"),
+      label: "",
+      kind: "pseudo",
+      pseudoKind: "final",
+      activities: [],
+      children: []
+    };
+    ctx.finalAlias = node2.id;
+    ctx.byId.set(node2.id, node2);
+    ctx.states.push(node2);
+    return node2;
+  }
+  for (const child of parent.children) {
+    if (child.id.startsWith("__final_") && child.label === "") return child;
+  }
+  const node = {
+    id: newPseudoId(ctx, "final"),
+    label: "",
+    kind: "pseudo",
+    pseudoKind: "final",
+    activities: [],
+    children: [],
+    parent: parent.id
+  };
+  ctx.byId.set(node.id, node);
+  parent.children.push(node);
+  return node;
+}
+function ensureSimpleState(ctx, id, parent) {
+  const existing = ctx.byId.get(id);
+  if (existing) return existing;
+  const node = {
+    id,
+    label: id,
+    kind: "simple",
+    activities: [],
+    children: [],
+    parent: parent?.id
+  };
+  ctx.byId.set(id, node);
+  if (parent) parent.children.push(node);
+  else ctx.states.push(node);
+  return node;
+}
+function isIdent(tok) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(tok);
+}
+function parseStateDiagram(src) {
+  const lines = preprocess3(src);
+  if (lines.length === 0) {
+    throw new StateParseError("Empty document");
+  }
+  const header = lines[0];
+  const headerTok = header.text.match(/^(stateDiagram-v2|stateDiagram|state)\b/i);
+  if (!headerTok) {
+    throw new StateParseError(
+      `Expected 'state' or 'stateDiagram' header, got '${header.text}'`,
+      header.line
+    );
+  }
+  let title2;
+  let direction = "TB";
+  const headerRest = header.text.slice(headerTok[0].length).trim();
+  const propsMatch = headerRest.match(/\[[^\]]*\]\s*$/);
+  let beforeProps = headerRest;
+  if (propsMatch) {
+    const props = parseProps(propsMatch[0]);
+    if (props.direction === "TB" || props.direction === "LR") direction = props.direction;
+    beforeProps = headerRest.slice(0, propsMatch.index).trim();
+  }
+  if (beforeProps.startsWith('"')) title2 = unquote2(beforeProps);
+  else if (beforeProps.length > 0) title2 = beforeProps;
+  const ctx = {
+    states: [],
+    transitions: [],
+    notes: [],
+    pseudoCounter: 0,
+    noteCounter: 0,
+    transCounter: 0,
+    byId: /* @__PURE__ */ new Map()
+  };
+  const compositeStack = [{ parent: void 0, regionMode: false }];
+  let i = 1;
+  while (i < lines.length) {
+    const ln = lines[i];
+    const text2 = ln.text;
+    const ctxTop = compositeStack[compositeStack.length - 1];
+    const parent = ctxTop.parent;
+    if (text2 === "}") {
+      if (compositeStack.length <= 1) {
+        throw new StateParseError("Unexpected '}'", ln.line);
+      }
+      compositeStack.pop();
+      i++;
+      continue;
+    }
+    if (text2 === "---" || text2 === "--") {
+      if (!parent) {
+        throw new StateParseError(
+          "Region separator only allowed inside a composite",
+          ln.line
+        );
+      }
+      ctxTop.regionMode = true;
+      if (!parent.regions) parent.regions = [];
+      const lastIdx = parent.regions.reduce((s, r) => s + r.length, 0);
+      const slice = parent.children.slice(lastIdx);
+      parent.regions.push(slice);
+      i++;
+      continue;
+    }
+    const dirMatch = text2.match(/^direction\s+(TB|BT|LR|RL)\s*$/);
+    if (dirMatch) {
+      const d = dirMatch[1];
+      direction = d === "BT" ? "TB" : d === "RL" ? "LR" : d;
+      i++;
+      continue;
+    }
+    const compMatch = text2.match(/^(?:composite|state)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\{?\s*$/);
+    const isCompositeWithBrace = compMatch && text2.endsWith("{");
+    if (isCompositeWithBrace) {
+      const id = compMatch[1];
+      const node = ensureSimpleState(ctx, id, parent);
+      node.kind = "composite";
+      compositeStack.push({ parent: node, regionMode: false });
+      i++;
+      continue;
+    }
+    const aliasMatch = text2.match(/^state\s+"([^"]*)"\s+as\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/);
+    if (aliasMatch) {
+      const node = ensureSimpleState(ctx, aliasMatch[2], parent);
+      node.label = aliasMatch[1];
+      i++;
+      continue;
+    }
+    const stereoMatch = text2.match(/^state\s+([A-Za-z_][A-Za-z0-9_]*)\s+<<\s*(choice|fork|join|end)\s*>>\s*$/);
+    if (stereoMatch) {
+      const id = stereoMatch[1];
+      const kind = MERMAID_STEREOTYPE[stereoMatch[2]];
+      const node = {
+        id,
+        label: "",
+        kind: "pseudo",
+        pseudoKind: kind,
+        activities: [],
+        children: [],
+        parent: parent?.id
+      };
+      ctx.byId.set(id, node);
+      if (parent) parent.children.push(node);
+      else ctx.states.push(node);
+      i++;
+      continue;
+    }
+    const stateLabelMatch = text2.match(/^state\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.+)$/);
+    if (stateLabelMatch) {
+      const node = ensureSimpleState(ctx, stateLabelMatch[1], parent);
+      node.label = unquote2(stateLabelMatch[2].trim());
+      i++;
+      continue;
+    }
+    const pseudoMatch = text2.match(
+      /^(initial|final|choice|junction|fork|join|history|dhistory|terminate|entry_point|exit_point)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/
+    );
+    if (pseudoMatch) {
+      const kindKw = pseudoMatch[1];
+      const id = pseudoMatch[2];
+      const pkind = PSEUDO_KEYWORDS[kindKw];
+      const node = {
+        id,
+        label: "",
+        kind: "pseudo",
+        pseudoKind: pkind,
+        activities: [],
+        children: [],
+        parent: parent?.id
+      };
+      ctx.byId.set(id, node);
+      if (parent) parent.children.push(node);
+      else ctx.states.push(node);
+      i++;
+      continue;
+    }
+    if (parent) {
+      const activity = parseActivityLine(text2);
+      if (activity && (activity.kind === "entry" || activity.kind === "exit" || activity.kind === "do")) {
+        parent.activities.push(activity);
+        i++;
+        continue;
+      }
+    }
+    const noteSimple = text2.match(
+      /^note\s+(left[_ ]of|right[_ ]of)\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/
+    );
+    if (noteSimple) {
+      const side = noteSimple[1].startsWith("left") ? "left" : "right";
+      const target = noteSimple[2];
+      ctx.noteCounter += 1;
+      ctx.notes.push({
+        id: `__note_${ctx.noteCounter}`,
+        target,
+        side,
+        text: noteSimple[3].trim()
+      });
+      i++;
+      continue;
+    }
+    const noteBlockMermaid = text2.match(
+      /^note\s+(left[_ ]of|right[_ ]of)\s+([A-Za-z_][A-Za-z0-9_]*)\s*$/
+    );
+    if (noteBlockMermaid) {
+      const side = noteBlockMermaid[1].startsWith("left") ? "left" : "right";
+      const target = noteBlockMermaid[2];
+      const buf = [];
+      i++;
+      while (i < lines.length) {
+        const t = lines[i].text;
+        if (t === "end note" || t === "}") break;
+        buf.push(t);
+        i++;
+      }
+      if (i >= lines.length) {
+        throw new StateParseError("Unterminated note block", ln.line);
+      }
+      i++;
+      ctx.noteCounter += 1;
+      ctx.notes.push({
+        id: `__note_${ctx.noteCounter}`,
+        target,
+        side,
+        text: buf.join("\n")
+      });
+      continue;
+    }
+    const noteBlockSchematex = text2.match(
+      /^note\s+(left[_ ]of\s+|right[_ ]of\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*\{\s*$/
+    );
+    if (noteBlockSchematex) {
+      const side = noteBlockSchematex[1]?.startsWith("left") ? "left" : "right";
+      const target = noteBlockSchematex[2];
+      const buf = [];
+      i++;
+      while (i < lines.length && lines[i].text !== "}") {
+        buf.push(lines[i].text);
+        i++;
+      }
+      if (i >= lines.length) {
+        throw new StateParseError("Unterminated note block", ln.line);
+      }
+      i++;
+      ctx.noteCounter += 1;
+      ctx.notes.push({
+        id: `__note_${ctx.noteCounter}`,
+        target,
+        side,
+        text: buf.join("\n")
+      });
+      continue;
+    }
+    const transMatch = text2.match(
+      /^(\[\*\]|[A-Za-z_][A-Za-z0-9_]*)\s*-+>\s*(\[\*\]|[A-Za-z_][A-Za-z0-9_]*)\s*(?::\s*(.*))?$/
+    );
+    if (transMatch) {
+      const fromTok = transMatch[1];
+      const toTok = transMatch[2];
+      const labelRaw = transMatch[3];
+      const resolveTok = (tok, position) => {
+        if (tok === "[*]") {
+          if (position === "from") return ensureInitialAlias(ctx, parent).id;
+          return ensureFinalAlias(ctx, parent).id;
+        }
+        return ensureSimpleState(ctx, tok, parent).id;
+      };
+      const fromId = resolveTok(fromTok, "from");
+      const toId = resolveTok(toTok, "to");
+      ctx.transCounter += 1;
+      const tid = `t${ctx.transCounter}`;
+      const parsedLabel = labelRaw ? parseTransitionLabel(labelRaw) : {};
+      ctx.transitions.push({
+        id: tid,
+        from: fromId,
+        to: toId,
+        trigger: parsedLabel.trigger,
+        guard: parsedLabel.guard,
+        action: parsedLabel.action
+      });
+      i++;
+      continue;
+    }
+    const labelOnlyMatch = text2.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.+)$/);
+    if (labelOnlyMatch && isIdent(labelOnlyMatch[1])) {
+      const node = ensureSimpleState(ctx, labelOnlyMatch[1], parent);
+      node.label = unquote2(labelOnlyMatch[2].trim());
+      i++;
+      continue;
+    }
+    const bareIdent = text2.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*$/);
+    if (bareIdent) {
+      ensureSimpleState(ctx, bareIdent[1], parent);
+      i++;
+      continue;
+    }
+    throw new StateParseError(`Unparseable line: ${text2}`, ln.line);
+  }
+  if (compositeStack.length > 1) {
+    throw new StateParseError("Unclosed composite block (expected '}')");
+  }
+  function finalizeRegions(node) {
+    if (node.regions) {
+      const consumed = node.regions.reduce((s, r) => s + r.length, 0);
+      if (node.children.length > consumed) {
+        node.regions.push(node.children.slice(consumed));
+      }
+    }
+    for (const child of node.children) finalizeRegions(child);
+  }
+  for (const s of ctx.states) finalizeRegions(s);
+  return {
+    type: "state",
+    title: title2,
+    direction,
+    states: ctx.states,
+    transitions: ctx.transitions,
+    notes: ctx.notes
+  };
+}
+
+// src/diagrams/state/layout.ts
+var PSEUDO_BBOX = {
+  initial: { w: 22, h: 22 },
+  final: { w: 28, h: 28 },
+  choice: { w: 32, h: 32 },
+  junction: { w: 16, h: 16 },
+  fork: { w: 100, h: 8 },
+  // horizontal bar — rotated for LR direction below
+  join: { w: 100, h: 8 },
+  history: { w: 26, h: 26 },
+  dhistory: { w: 30, h: 30 },
+  terminate: { w: 22, h: 22 },
+  entry_point: { w: 18, h: 18 },
+  exit_point: { w: 18, h: 18 }
+};
+var NOTE_W = 180;
+var NOTE_LINE_H = 14;
+function shapeForState(node) {
+  if (node.kind === "simple") return "round";
+  if (node.kind === "composite") return "round";
+  switch (node.pseudoKind) {
+    case "initial":
+    case "final":
+    case "junction":
+    case "history":
+    case "dhistory":
+    case "terminate":
+    case "entry_point":
+    case "exit_point":
+      return "circle";
+    case "choice":
+      return "diamond";
+    case "fork":
+    case "join":
+      return "rect";
+    default:
+      return "round";
+  }
+}
+function buildLabel(t) {
+  const parts = [];
+  if (t.trigger) parts.push(t.trigger);
+  if (t.guard) parts.push(`[${t.guard}]`);
+  let s = parts.join(" ");
+  if (t.action) s = s ? `${s} / ${t.action}` : `/ ${t.action}`;
+  return s.trim() || void 0;
+}
+function convertToFlowchart(ast) {
+  const fcNodes = [];
+  const fcSubgraphs = [];
+  const pseudoSizes = /* @__PURE__ */ new Map();
+  const compositeEntryFor = /* @__PURE__ */ new Map();
+  const compositeExitFor = /* @__PURE__ */ new Map();
+  const visit = (s, parentId) => {
+    if (s.kind === "composite") {
+      const childIds = [];
+      const childSgIds = [];
+      for (const child of s.children) {
+        if (child.kind === "composite") childSgIds.push(child.id);
+        else childIds.push(child.id);
+      }
+      let entryChild;
+      let exitChild;
+      for (const child of s.children) {
+        if (child.kind === "pseudo" && child.pseudoKind === "initial" && !entryChild) {
+          entryChild = child.id;
+        }
+        if (child.kind === "pseudo" && child.pseudoKind === "final") {
+          exitChild = child.id;
+        }
+      }
+      if (!entryChild) entryChild = s.children[0]?.id;
+      if (!exitChild) exitChild = s.children[s.children.length - 1]?.id;
+      if (entryChild) compositeEntryFor.set(s.id, entryChild);
+      if (exitChild) compositeExitFor.set(s.id, exitChild);
+      fcSubgraphs.push({
+        id: s.id,
+        label: s.label || s.id,
+        direction: ast.direction,
+        children: childIds,
+        subgraphs: childSgIds
+      });
+      for (const child of s.children) visit(child, s.id);
+      return;
+    }
+    const node = {
+      id: s.id,
+      label: labelForFlowchart(s),
+      shape: shapeForState(s),
+      parent: parentId
+    };
+    fcNodes.push(node);
+    if (s.kind === "pseudo" && s.pseudoKind) {
+      pseudoSizes.set(s.id, { ...PSEUDO_BBOX[s.pseudoKind] });
+    }
+  };
+  for (const s of ast.states) visit(s, void 0);
+  const fcEdges = ast.transitions.map((t) => {
+    let from = t.from;
+    let to = t.to;
+    const fromExit = compositeExitFor.get(t.from);
+    if (fromExit) from = fromExit;
+    const toEntry = compositeEntryFor.get(t.to);
+    if (toEntry) to = toEntry;
+    return {
+      id: t.id,
+      from,
+      to,
+      kind: "solid",
+      label: buildLabel(t)
+    };
+  });
+  const fc = {
+    type: "flowchart",
+    title: ast.title,
+    direction: ast.direction === "LR" ? "LR" : "TB",
+    nodes: fcNodes,
+    edges: fcEdges,
+    subgraphs: fcSubgraphs,
+    classDefs: [],
+    linkStyles: /* @__PURE__ */ new Map()
+  };
+  return { ast: fc, pseudoSizes };
+}
+function labelForFlowchart(s) {
+  if (s.kind === "pseudo") return "";
+  if (s.activities.length === 0) return s.label || s.id;
+  const activityWidth = s.activities.map((a) => activityText(a).length).reduce((m, n) => Math.max(m, n), 0);
+  const label = s.label || s.id;
+  return label.length >= activityWidth ? label : "x".repeat(activityWidth);
+}
+function activityText(a) {
+  if (a.kind === "entry" || a.kind === "exit" || a.kind === "do") {
+    return `${a.kind} / ${a.action ?? ""}`;
+  }
+  const parts = [];
+  if (a.trigger) parts.push(a.trigger);
+  if (a.guard) parts.push(`[${a.guard}]`);
+  let s = parts.join(" ");
+  if (a.action) s = s ? `${s} / ${a.action}` : `/ ${a.action}`;
+  return s;
+}
+function wrapNoteText(text2, charsPerLine = 28) {
+  const out = [];
+  for (const para of text2.split(/\n/)) {
+    const words = para.split(/\s+/);
+    let cur = "";
+    for (const w of words) {
+      if (!cur) cur = w;
+      else if (cur.length + w.length + 1 <= charsPerLine) cur += ` ${w}`;
+      else {
+        out.push(cur);
+        cur = w;
+      }
+    }
+    if (cur) out.push(cur);
+    if (para === "") out.push("");
+  }
+  return out.length ? out : [""];
+}
+function selfLoopPath(cx, cy, w, h) {
+  const startX = cx + w / 2;
+  const startY = cy - h * 0.15;
+  const endX = cx + w * 0.15;
+  const endY = cy - h / 2;
+  const c1x = startX + 28;
+  const c1y = startY - 12;
+  const c2x = endX + 28;
+  const c2y = endY - 28;
+  const path2 = `M ${startX} ${startY} C ${c1x} ${c1y}, ${c2x} ${c2y}, ${endX} ${endY}`;
+  return { path: path2, labelX: startX + 28, labelY: startY - 18 };
+}
+function layoutStateDiagram(ast) {
+  const { ast: fcAst, pseudoSizes } = convertToFlowchart(ast);
+  const selfLoops = [];
+  fcAst.edges = fcAst.edges.filter((e) => {
+    if (e.from === e.to) {
+      const t = ast.transitions.find((tr) => tr.id === e.id);
+      if (t) selfLoops.push(t);
+      return false;
+    }
+    return true;
+  });
+  const fcResult = layoutFlowchart(fcAst);
+  const stateById = /* @__PURE__ */ new Map();
+  const collectStates = (s) => {
+    stateById.set(s.id, s);
+    for (const c of s.children) collectStates(c);
+  };
+  for (const s of ast.states) collectStates(s);
+  const stateNodes = [];
+  for (const fcNode of fcResult.nodes) {
+    if (fcNode.isDummy) continue;
+    const s = stateById.get(fcNode.node.id);
+    if (!s) continue;
+    if (s.kind === "composite") continue;
+    const cx = fcNode.x + fcNode.width / 2;
+    const cy = fcNode.y + fcNode.height / 2;
+    let w = fcNode.width;
+    let h = fcNode.height;
+    if (s.kind === "pseudo" && s.pseudoKind) {
+      const ps = pseudoSizes.get(s.id);
+      if (ps) {
+        if ((s.pseudoKind === "fork" || s.pseudoKind === "join") && ast.direction === "LR") {
+          w = 8;
+          h = 100;
+        } else {
+          w = ps.w;
+          h = ps.h;
+        }
+      }
+    }
+    stateNodes.push({
+      id: s.id,
+      x: cx - w / 2,
+      y: cy - h / 2,
+      width: w,
+      height: h,
+      cx,
+      cy,
+      layer: fcNode.layer,
+      node: s,
+      parent: s.parent
+    });
+  }
+  const clusters = fcResult.clusters.map((c) => {
+    const s = stateById.get(c.subgraph.id);
+    if (!s) {
+      return {
+        id: c.subgraph.id,
+        state: { id: c.subgraph.id, label: c.subgraph.label, kind: "composite", activities: [], children: [] },
+        x: c.x,
+        y: c.y,
+        width: c.width,
+        height: c.height
+      };
+    }
+    return {
+      id: c.subgraph.id,
+      state: s,
+      x: c.x,
+      y: c.y,
+      width: c.width,
+      height: c.height
+    };
+  });
+  const stateById2 = new Map(stateNodes.map((n) => [n.id, n]));
+  const stateEdges = [];
+  for (const fcEdge of fcResult.edges) {
+    const t = ast.transitions.find((tr) => tr.id === fcEdge.edge.id);
+    if (!t) continue;
+    let path2 = fcEdge.path;
+    const sourceNode = stateById2.get(fcEdge.edge.from);
+    const targetNode = stateById2.get(fcEdge.edge.to);
+    if (sourceNode && sourceNode.node.kind === "pseudo") {
+      path2 = trimPathStart(path2, sourceNode.cx, sourceNode.cy, symbolRadius(sourceNode));
+    }
+    if (targetNode && targetNode.node.kind === "pseudo") {
+      path2 = trimPathEnd(path2, targetNode.cx, targetNode.cy, symbolRadius(targetNode));
+    }
+    stateEdges.push({
+      id: t.id,
+      from: t.from,
+      to: t.to,
+      path: path2,
+      label: buildLabel(t),
+      labelX: fcEdge.labelAnchor?.x ?? 0,
+      labelY: fcEdge.labelAnchor?.y ?? 0,
+      labelAnchor: fcEdge.labelAnchor?.textAnchor ?? "middle"
+    });
+  }
+  for (const sl of selfLoops) {
+    const host = stateById2.get(sl.from);
+    if (!host) continue;
+    const { path: path2, labelX, labelY } = selfLoopPath(host.cx, host.cy, host.width, host.height);
+    stateEdges.push({
+      id: sl.id,
+      from: sl.from,
+      to: sl.to,
+      path: path2,
+      label: buildLabel(sl),
+      labelX,
+      labelY,
+      labelAnchor: "start",
+      selfLoop: true
+    });
+  }
+  const notes = [];
+  for (const note of ast.notes) {
+    const target = stateById2.get(note.target);
+    if (!target) continue;
+    const lines = wrapNoteText(note.text);
+    const w = NOTE_W;
+    const h = lines.length * NOTE_LINE_H + 14;
+    let x;
+    let y;
+    let leaderX1;
+    let leaderX2;
+    if (note.side === "left") {
+      x = target.x - w - 24;
+      y = target.cy - h / 2;
+      leaderX1 = target.x;
+      leaderX2 = x + w;
+    } else {
+      x = target.x + target.width + 24;
+      y = target.cy - h / 2;
+      leaderX1 = target.x + target.width;
+      leaderX2 = x;
+    }
+    notes.push({
+      note,
+      x,
+      y,
+      width: w,
+      height: h,
+      lines,
+      leader: { x1: leaderX1, y1: target.cy, x2: leaderX2, y2: y + h / 2 }
+    });
+  }
+  let maxX = fcResult.width;
+  let maxY = fcResult.height;
+  let minX = 0;
+  for (const n of notes) {
+    maxX = Math.max(maxX, n.x + n.width + 8);
+    maxY = Math.max(maxY, n.y + n.height + 8);
+    minX = Math.min(minX, n.x - 8);
+  }
+  if (minX < 0) {
+    const dx = -minX;
+    for (const n of stateNodes) {
+      n.x += dx;
+      n.cx += dx;
+    }
+    for (const c of clusters) {
+      c.x += dx;
+    }
+    for (const e of stateEdges) {
+      e.path = shiftPathX(e.path, dx);
+      e.labelX += dx;
+    }
+    for (const n of notes) {
+      n.x += dx;
+      n.leader.x1 += dx;
+      n.leader.x2 += dx;
+    }
+    maxX += dx;
+  }
+  for (const e of stateEdges) {
+    if (!e.selfLoop) continue;
+    maxX = Math.max(maxX, e.labelX + 60);
+    maxY = Math.max(maxY, e.labelY + 60);
+  }
+  const titleOffset = ast.title ? 28 : 0;
+  if (titleOffset) {
+    for (const n of stateNodes) {
+      n.y += titleOffset;
+      n.cy += titleOffset;
+    }
+    for (const c of clusters) {
+      c.y += titleOffset;
+    }
+    for (const e of stateEdges) {
+      e.path = shiftPathY(e.path, titleOffset);
+      e.labelY += titleOffset;
+    }
+    for (const n of notes) {
+      n.y += titleOffset;
+      n.leader.y1 += titleOffset;
+      n.leader.y2 += titleOffset;
+    }
+    maxY += titleOffset;
+  }
+  return {
+    width: maxX,
+    height: maxY,
+    nodes: stateNodes,
+    edges: stateEdges,
+    clusters,
+    notes,
+    title: ast.title,
+    direction: ast.direction
+  };
+}
+function symbolRadius(node) {
+  const k = node.node.pseudoKind;
+  switch (k) {
+    case "initial":
+      return 8;
+    case "final":
+      return 11;
+    case "choice":
+      return 14;
+    case "junction":
+      return 6;
+    case "history":
+      return 12;
+    case "dhistory":
+      return 13;
+    case "terminate":
+      return 8;
+    case "entry_point":
+    case "exit_point":
+      return 7;
+    case "fork":
+    case "join":
+      return Math.min(node.width, node.height) / 2;
+    default:
+      return Math.min(node.width, node.height) / 2;
+  }
+}
+function parsePathPoints(d) {
+  if (/[CSQTA]/.test(d)) return null;
+  const tokens = d.match(/[ML]\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/g) ?? [];
+  const out = [];
+  for (const tok of tokens) {
+    const m = tok.match(/[ML]\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+    if (!m) continue;
+    out.push({ x: parseFloat(m[1]), y: parseFloat(m[2]) });
+  }
+  return out;
+}
+function pointsToPath(pts) {
+  if (pts.length === 0) return "";
+  const head = `M ${pts[0].x} ${pts[0].y}`;
+  const rest = pts.slice(1).map((p) => `L ${p.x} ${p.y}`).join(" ");
+  return rest ? `${head} ${rest}` : head;
+}
+function trimPathStart(d, cx, cy, r) {
+  const pts = parsePathPoints(d);
+  if (!pts || pts.length < 2) return d;
+  const p0 = pts[0];
+  const p1 = pts[1];
+  const newP0 = projectOnPerimeter(p0, p1, cx, cy, r);
+  pts[0] = newP0;
+  return pointsToPath(pts);
+}
+function trimPathEnd(d, cx, cy, r) {
+  const pts = parsePathPoints(d);
+  if (!pts || pts.length < 2) return d;
+  const last = pts[pts.length - 1];
+  const prev = pts[pts.length - 2];
+  const newLast = projectOnPerimeter(last, prev, cx, cy, r);
+  pts[pts.length - 1] = newLast;
+  return pointsToPath(pts);
+}
+function projectOnPerimeter(endpoint, neighbor, cx, cy, r) {
+  const dx = endpoint.x - neighbor.x;
+  const dy = endpoint.y - neighbor.y;
+  if (Math.abs(dx) > Math.abs(dy)) {
+    const sign2 = dx >= 0 ? 1 : -1;
+    return { x: cx - sign2 * r, y: cy };
+  }
+  const sign = dy >= 0 ? 1 : -1;
+  return { x: cx, y: cy - sign * r };
+}
+function shiftPathX(d, dx) {
+  return d.replace(/([MLCQ])\s*((?:-?\d+(?:\.\d+)?\s+){1,5}-?\d+(?:\.\d+)?)/g, (_, cmd, args) => {
+    const nums = args.trim().split(/\s+/).map(Number);
+    const out = [];
+    for (let i = 0; i < nums.length; i++) {
+      out.push(i % 2 === 0 ? nums[i] + dx : nums[i]);
+    }
+    return `${cmd} ${out.join(" ")}`;
+  });
+}
+function shiftPathY(d, dy) {
+  return d.replace(/([MLCQ])\s*((?:-?\d+(?:\.\d+)?\s+){1,5}-?\d+(?:\.\d+)?)/g, (_, cmd, args) => {
+    const nums = args.trim().split(/\s+/).map(Number);
+    const out = [];
+    for (let i = 0; i < nums.length; i++) {
+      out.push(i % 2 === 1 ? nums[i] + dy : nums[i]);
+    }
+    return `${cmd} ${out.join(" ")}`;
+  });
+}
+
+// src/diagrams/state/renderer.ts
+var ARROW_MARKER_ID = "lt-state-arrow";
+var STYLE = `
+.lt-state-body { fill: #ffffff; stroke: #2a2a2a; stroke-width: 1.6; }
+.lt-state-name { font: 600 12px system-ui, sans-serif; fill: #1a1a1a; }
+.lt-state-div  { stroke: #2a2a2a; stroke-width: 1; }
+.lt-state-activity { font: 11px ui-monospace, monospace; fill: #444; }
+
+.lt-composite-body { fill: #fafafa; stroke: #2a2a2a; stroke-width: 1.6; }
+.lt-composite-title { font: 600 12px system-ui, sans-serif; fill: #1a1a1a; }
+.lt-composite-titlebar { fill: #f0f0f0; stroke: #2a2a2a; stroke-width: 1; }
+.lt-region-div { stroke: #888; stroke-width: 1; stroke-dasharray: 6 4; }
+
+.lt-ps-initial { fill: #1a1a1a; }
+.lt-ps-final-outer { fill: #ffffff; stroke: #1a1a1a; stroke-width: 1.6; }
+.lt-ps-final-inner { fill: #1a1a1a; }
+.lt-ps-choice { fill: #ffffff; stroke: #1a1a1a; stroke-width: 1.6; }
+.lt-ps-junction { fill: #1a1a1a; }
+.lt-ps-bar { fill: #1a1a1a; }
+.lt-ps-history-body { fill: #ffffff; stroke: #1a1a1a; stroke-width: 1.6; }
+.lt-ps-history-text { font: 600 11px serif; fill: #1a1a1a; }
+.lt-ps-terminate { stroke: #1a1a1a; stroke-width: 2; }
+.lt-ps-entrypoint { fill: #ffffff; stroke: #1a1a1a; stroke-width: 1.6; }
+.lt-ps-exitpoint  { fill: #ffffff; stroke: #1a1a1a; stroke-width: 1.6; }
+
+.lt-transition { stroke: #2a2a2a; stroke-width: 1.4; fill: none; }
+.lt-transition-label { font: 11px system-ui, sans-serif; fill: #1a1a1a; }
+.lt-transition-label-bg { fill: #ffffff; opacity: 0.92; }
+
+.lt-note-body { fill: #fff8c5; stroke: #b79400; stroke-width: 1; }
+.lt-note-text { font: 11px system-ui, sans-serif; fill: #2a2a2a; }
+.lt-note-leader { stroke: #b79400; stroke-width: 1; stroke-dasharray: 3 3; fill: none; }
+
+.lt-title { font: 600 14px system-ui, sans-serif; fill: #1a1a1a; }
+`;
+function renderArrowMarker() {
+  return el(
+    "marker",
+    {
+      id: ARROW_MARKER_ID,
+      markerWidth: 10,
+      markerHeight: 10,
+      refX: 9,
+      refY: 3,
+      orient: "auto",
+      markerUnits: "strokeWidth"
+    },
+    [polygon({ points: "0,0 10,3 0,6", fill: "#2a2a2a" })]
+  );
+}
+function activityText2(a) {
+  if (a.kind === "entry" || a.kind === "exit" || a.kind === "do") {
+    return `${a.kind} / ${a.action ?? ""}`;
+  }
+  const parts = [];
+  if (a.trigger) parts.push(a.trigger);
+  if (a.guard) parts.push(`[${a.guard}]`);
+  let s = parts.join(" ");
+  if (a.action) s = s ? `${s} / ${a.action}` : `/ ${a.action}`;
+  return s;
+}
+function renderSimple(node) {
+  const { x, y, width, height } = node;
+  const children = [
+    rect({ x, y, width, height, rx: 8, ry: 8, class: "lt-state-body" })
+  ];
+  const label = node.node.label || node.id;
+  if (node.node.activities.length === 0) {
+    children.push(
+      text(
+        { x: x + width / 2, y: y + height / 2 + 4, "text-anchor": "middle", class: "lt-state-name" },
+        label
+      )
+    );
+  } else {
+    children.push(
+      text(
+        { x: x + width / 2, y: y + 16, "text-anchor": "middle", class: "lt-state-name" },
+        label
+      )
+    );
+    children.push(
+      line({ x1: x, y1: y + 22, x2: x + width, y2: y + 22, class: "lt-state-div" })
+    );
+    let cy = y + 36;
+    for (const a of node.node.activities) {
+      children.push(text({ x: x + 8, y: cy, class: "lt-state-activity" }, activityText2(a)));
+      cy += 14;
+    }
+  }
+  return group({ class: "lt-state lt-simple", "data-id": node.id }, children);
+}
+function renderComposite(c) {
+  const { x, y, width, height } = c;
+  const titleBarH = 22;
+  const acts = c.state.activities;
+  const actsH = acts.length ? acts.length * 14 + 6 : 0;
+  const parts = [
+    rect({ x, y, width, height, rx: 10, ry: 10, class: "lt-composite-body" }),
+    // Title bar background — only the top strip
+    path({
+      d: `M ${x + 1} ${y + titleBarH} L ${x + width - 1} ${y + titleBarH}`,
+      class: "lt-state-div"
+    }),
+    text(
+      { x: x + 12, y: y + 16, class: "lt-composite-title" },
+      c.state.label || c.state.id
+    )
+  ];
+  if (acts.length) {
+    let cy = y + titleBarH + 14;
+    for (const a of acts) {
+      parts.push(text({ x: x + 12, y: cy, class: "lt-state-activity" }, activityText2(a)));
+      cy += 14;
+    }
+    parts.push(
+      path({
+        d: `M ${x + 1} ${y + titleBarH + actsH} L ${x + width - 1} ${y + titleBarH + actsH}`,
+        class: "lt-state-div"
+      })
+    );
+  }
+  if (c.regionDividers) {
+    for (const yy of c.regionDividers) {
+      parts.push(
+        line({ x1: x + 1, y1: yy, x2: x + width - 1, y2: yy, class: "lt-region-div" })
+      );
+    }
+  }
+  return group(
+    { class: "lt-state lt-composite", "data-id": c.id },
+    parts
+  );
+}
+function renderPseudo(node) {
+  const cx = node.cx;
+  const cy = node.cy;
+  const k = node.node.pseudoKind;
+  switch (k) {
+    case "initial":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "initial" },
+        [circle({ cx, cy, r: 8, class: "lt-ps-initial" })]
+      );
+    case "final":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "final" },
+        [
+          circle({ cx, cy, r: 11, class: "lt-ps-final-outer" }),
+          circle({ cx, cy, r: 6, class: "lt-ps-final-inner" })
+        ]
+      );
+    case "choice": {
+      const r = 14;
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "choice" },
+        [
+          polygon({
+            points: `${cx},${cy - r} ${cx + r},${cy} ${cx},${cy + r} ${cx - r},${cy}`,
+            class: "lt-ps-choice"
+          })
+        ]
+      );
+    }
+    case "junction":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "junction" },
+        [circle({ cx, cy, r: 6, class: "lt-ps-junction" })]
+      );
+    case "fork":
+    case "join":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": k },
+        [rect({ x: node.x, y: node.y, width: node.width, height: node.height, rx: 2, ry: 2, class: "lt-ps-bar" })]
+      );
+    case "history":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "history" },
+        [
+          circle({ cx, cy, r: 12, class: "lt-ps-history-body" }),
+          text({ x: cx, y: cy + 4, "text-anchor": "middle", class: "lt-ps-history-text" }, "H")
+        ]
+      );
+    case "dhistory":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "dhistory" },
+        [
+          circle({ cx, cy, r: 13, class: "lt-ps-history-body" }),
+          text({ x: cx, y: cy + 4, "text-anchor": "middle", class: "lt-ps-history-text" }, "H*")
+        ]
+      );
+    case "terminate":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "terminate" },
+        [
+          line({ x1: cx - 8, y1: cy - 8, x2: cx + 8, y2: cy + 8, class: "lt-ps-terminate" }),
+          line({ x1: cx + 8, y1: cy - 8, x2: cx - 8, y2: cy + 8, class: "lt-ps-terminate" })
+        ]
+      );
+    case "entry_point":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "entry_point" },
+        [circle({ cx, cy, r: 7, class: "lt-ps-entrypoint" })]
+      );
+    case "exit_point":
+      return group(
+        { class: "lt-state lt-pseudo", "data-id": node.id, "data-kind": "exit_point" },
+        [
+          circle({ cx, cy, r: 7, class: "lt-ps-exitpoint" }),
+          line({ x1: cx - 4, y1: cy - 4, x2: cx + 4, y2: cy + 4, class: "lt-ps-terminate" }),
+          line({ x1: cx + 4, y1: cy - 4, x2: cx - 4, y2: cy + 4, class: "lt-ps-terminate" })
+        ]
+      );
+    default:
+      return "";
+  }
+}
+function renderNode(node) {
+  if (node.node.kind === "pseudo") return renderPseudo(node);
+  return renderSimple(node);
+}
+function renderEdge(edge) {
+  const parts = [
+    path({
+      d: edge.path,
+      class: "lt-transition",
+      "marker-end": `url(#${ARROW_MARKER_ID})`,
+      "data-from": edge.from,
+      "data-to": edge.to
+    })
+  ];
+  if (edge.label) {
+    const w = Math.max(20, edge.label.length * 6.4 + 8);
+    const anchor = edge.labelAnchor ?? "middle";
+    const dx = anchor === "start" ? 0 : anchor === "end" ? -w : -w / 2;
+    parts.push(
+      rect({
+        x: edge.labelX + dx,
+        y: edge.labelY - 10,
+        width: w,
+        height: 14,
+        rx: 2,
+        ry: 2,
+        class: "lt-transition-label-bg"
+      })
+    );
+    parts.push(
+      text(
+        {
+          x: edge.labelX,
+          y: edge.labelY,
+          "text-anchor": anchor,
+          class: "lt-transition-label"
+        },
+        edge.label
+      )
+    );
+  }
+  return group({ class: "lt-edge", "data-edge-id": edge.id }, parts);
+}
+function renderNote(n) {
+  const parts = [
+    line({
+      x1: n.leader.x1,
+      y1: n.leader.y1,
+      x2: n.leader.x2,
+      y2: n.leader.y2,
+      class: "lt-note-leader"
+    }),
+    rect({ x: n.x, y: n.y, width: n.width, height: n.height, rx: 4, ry: 4, class: "lt-note-body" })
+  ];
+  let yy = n.y + 14;
+  for (const ln of n.lines) {
+    parts.push(text({ x: n.x + 8, y: yy, class: "lt-note-text" }, ln));
+    yy += 14;
+  }
+  return group({ class: "lt-note", "data-target": n.note.target }, parts);
+}
+function renderStateDiagram(ast, _config) {
+  const layout = layoutStateDiagram(ast);
+  return renderLayout(layout);
+}
+function renderLayout(layout) {
+  const titleNode = layout.title ? text({ x: 16, y: 22, class: "lt-title" }, layout.title) : "";
+  return svgRoot(
+    {
+      width: layout.width,
+      height: layout.height,
+      viewBox: `0 0 ${layout.width} ${layout.height}`,
+      class: "lt-state",
+      "data-diagram-type": "state"
+    },
+    [
+      el("title", {}, escapeXml(`State Diagram${layout.title ? " \u2014 " + layout.title : ""}`)),
+      el("desc", {}, "UML 2.5 / Harel statechart rendered by Schematex"),
+      defs([renderArrowMarker(), el("style", {}, STYLE)]),
+      titleNode,
+      // Composite clusters first so simple-state bodies sit on top.
+      group({ class: "lt-clusters" }, layout.clusters.map(renderComposite)),
+      group({ class: "lt-state-bodies" }, layout.nodes.map(renderNode)),
+      group({ class: "lt-edges" }, layout.edges.map(renderEdge)),
+      group({ class: "lt-notes" }, layout.notes.map(renderNote))
+    ]
+  );
+}
+
+// src/diagrams/state/index.ts
+var state = {
+  type: "state",
+  detect(text2) {
+    return /^\s*state\b/i.test(text2);
+  },
+  parse: parseStateDiagram,
+  render(text2, config) {
+    const ast = parseStateDiagram(text2);
+    return renderStateDiagram(ast);
+  }
+};
+
+// src/diagrams/pid/parser.ts
+var PidParseError = class extends Error {
+  constructor(message, line2) {
+    super(line2 !== void 0 ? `Line ${line2}: ${message}` : message);
+    this.line = line2;
+    this.name = "PidParseError";
+  }
+  line;
+};
+var EQUIP_TYPES = /* @__PURE__ */ new Set([
+  "tank_atm",
+  "tank_cone_roof",
+  "vessel_v",
+  "vessel_h",
+  "sphere",
+  "column_tray",
+  "column_packed",
+  "hx_shell_tube",
+  "hx_air_cooled",
+  "reboiler",
+  "condenser",
+  "pump_centrifugal",
+  "pump_pd",
+  "compressor",
+  "blower",
+  "reactor_cstr",
+  "reactor_pfr",
+  "filter",
+  "cyclone",
+  "flare",
+  "cooling_tower",
+  "valve_gate",
+  "valve_ball",
+  "valve_globe",
+  "valve_butterfly",
+  "valve_check",
+  "valve_control",
+  "valve_psv"
+]);
+var LINE_TYPES = /* @__PURE__ */ new Set([
+  "process",
+  "process_minor",
+  "pneumatic",
+  "electric",
+  "hydraulic",
+  "capillary",
+  "software",
+  "mechanical"
+]);
+var INST_CATEGORIES = /* @__PURE__ */ new Set([
+  "field_discrete",
+  "field_shared",
+  "field_computer",
+  "field_plc",
+  "cr_discrete",
+  "cr_shared",
+  "cr_computer",
+  "cr_plc",
+  "local_discrete",
+  "local_shared"
+]);
+function preprocess4(src) {
+  const out = [];
+  const lines = src.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw === void 0) continue;
+    let stripped = "";
+    let inQuote = false;
+    for (const ch of raw) {
+      if (ch === '"') inQuote = !inQuote;
+      if (ch === "#" && !inQuote) break;
+      stripped += ch;
+    }
+    const trimmed = stripped.trim();
+    if (!trimmed) continue;
+    const indent = stripped.length - stripped.replace(/^\s+/, "").length;
+    out.push({ text: trimmed, indent, line: i + 1 });
+  }
+  return out;
+}
+function unquote3(s) {
+  const t = s.trim();
+  if (t.length >= 2 && t.startsWith('"') && t.endsWith('"')) {
+    return t.slice(1, -1).replace(/\\"/g, '"');
+  }
+  return t;
+}
+function parseAttrList(inside) {
+  const out = {};
+  const parts = [];
+  let depth = 0;
+  let inQuote = false;
+  let cur = "";
+  for (const ch of inside) {
+    if (ch === '"') inQuote = !inQuote;
+    if (!inQuote && ch === "[") depth++;
+    if (!inQuote && ch === "]") depth--;
+    if (!inQuote && depth === 0 && ch === ",") {
+      parts.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur.trim()) parts.push(cur);
+  for (const p of parts) {
+    const idx = p.indexOf(":");
+    if (idx < 0) continue;
+    const key = p.slice(0, idx).trim();
+    const val = unquote3(p.slice(idx + 1).trim());
+    out[key] = val;
+  }
+  return out;
+}
+function extractAttrs(text2) {
+  let depth = 0;
+  let inQuote = false;
+  let openIdx = -1;
+  for (let i = 0; i < text2.length; i++) {
+    const ch = text2[i];
+    if (ch === '"') inQuote = !inQuote;
+    if (inQuote) continue;
+    if (ch === "[") {
+      if (depth === 0) openIdx = i;
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0 && i === text2.length - 1) {
+        const inside = text2.slice(openIdx + 1, i);
+        return {
+          rest: text2.slice(0, openIdx).trim(),
+          attrs: parseAttrList(inside)
+        };
+      }
+    }
+  }
+  return { rest: text2, attrs: {} };
+}
+function parseAnchor(tok) {
+  const dot = tok.indexOf(".");
+  if (dot < 0) return { id: tok };
+  return { id: tok.slice(0, dot), port: tok.slice(dot + 1) };
+}
+function parsePid(src) {
+  const lines = preprocess4(src);
+  if (lines.length === 0) {
+    throw new PidParseError("Empty document");
+  }
+  const header = lines[0];
+  if (!/^pid\b/i.test(header.text)) {
+    throw new PidParseError(`Expected 'pid' header, got '${header.text}'`, header.line);
+  }
+  let title2;
+  let direction = "LR";
+  const headerRest = header.text.replace(/^pid\b/i, "").trim();
+  const { rest, attrs: headerAttrs } = extractAttrs(headerRest);
+  if (headerAttrs.direction === "TB") direction = "TB";
+  if (headerAttrs.direction === "LR") direction = "LR";
+  if (rest) title2 = unquote3(rest);
+  const equipment = [];
+  const linesAst = [];
+  const instruments = [];
+  let currentInst;
+  for (let idx = 1; idx < lines.length; idx++) {
+    const ln = lines[idx];
+    const text2 = ln.text;
+    const measuresMatch = text2.match(/^measures\s+(.+)$/);
+    if (measuresMatch && currentInst) {
+      currentInst.measures = measuresMatch[1].trim();
+      continue;
+    }
+    const controlsMatch = text2.match(/^controls\s+(.+)$/);
+    if (controlsMatch && currentInst) {
+      currentInst.controls = controlsMatch[1].trim();
+      continue;
+    }
+    currentInst = void 0;
+    const equipMatch = text2.match(/^equip\s+([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.+)$/);
+    if (equipMatch) {
+      const id = equipMatch[1];
+      const tail = equipMatch[2];
+      const { rest: typeRest, attrs } = extractAttrs(tail);
+      const equipType = typeRest.trim();
+      if (!EQUIP_TYPES.has(equipType)) {
+        throw new PidParseError(`Unknown equipment type '${equipType}'`, ln.line);
+      }
+      equipment.push({
+        id,
+        equipType,
+        tag: attrs.tag ?? id,
+        attrs
+      });
+      continue;
+    }
+    const lineMatch = text2.match(/^line\s+([A-Za-z0-9_-]+)\s+from\s+(\S+)\s+to\s+(\S+)\s*(.*)$/);
+    if (lineMatch) {
+      const id = lineMatch[1];
+      const fromTok = lineMatch[2];
+      const toTok = lineMatch[3];
+      const tail = lineMatch[4];
+      const { attrs } = extractAttrs(tail);
+      const lt = attrs.type ?? "process";
+      if (!LINE_TYPES.has(lt)) {
+        throw new PidParseError(`Unknown line type '${lt}'`, ln.line);
+      }
+      linesAst.push({
+        id,
+        from: parseAnchor(fromTok),
+        to: parseAnchor(toTok),
+        lineType: lt,
+        tag: attrs.tag,
+        size: attrs.size,
+        service: attrs.service,
+        attrs
+      });
+      continue;
+    }
+    const instMatch = text2.match(/^inst\s+([A-Z][A-Z0-9]*-[A-Za-z0-9]+)\s*:\s*(.+)$/);
+    if (instMatch) {
+      const tag = instMatch[1];
+      const { rest: catRest, attrs } = extractAttrs(instMatch[2]);
+      const category = catRest.trim();
+      if (!INST_CATEGORIES.has(category)) {
+        throw new PidParseError(`Unknown instrument category '${category}'`, ln.line);
+      }
+      const inst = {
+        tag,
+        category,
+        attrs
+      };
+      instruments.push(inst);
+      currentInst = inst;
+      continue;
+    }
+    throw new PidParseError(`Unparseable line: ${text2}`, ln.line);
+  }
+  return {
+    type: "pid",
+    title: title2,
+    direction,
+    equipment,
+    lines: linesAst,
+    instruments
+  };
+}
+
+// src/diagrams/pid/symbols.ts
+var GEOMETRY = {
+  // ── Tanks & vessels ─────────────────────────────────────
+  tank_atm: {
+    width: 90,
+    height: 90,
+    ports: {
+      top: { x: 0, y: -45 },
+      bottom: { x: 0, y: 45 },
+      left: { x: -45, y: 0 },
+      right: { x: 45, y: 0 },
+      in: { x: -45, y: 0 },
+      out: { x: 45, y: 0 }
+    }
+  },
+  tank_cone_roof: {
+    width: 90,
+    height: 100,
+    ports: {
+      top: { x: 0, y: -50 },
+      bottom: { x: 0, y: 50 },
+      left: { x: -45, y: 0 },
+      right: { x: 45, y: 0 }
+    }
+  },
+  vessel_v: {
+    width: 70,
+    height: 130,
+    ports: {
+      top: { x: 0, y: -65 },
+      bottom: { x: 0, y: 65 },
+      left: { x: -35, y: 0 },
+      right: { x: 35, y: 0 },
+      in: { x: -35, y: -25 },
+      out: { x: 35, y: 25 }
+    }
+  },
+  vessel_h: {
+    width: 130,
+    height: 70,
+    ports: {
+      top: { x: 0, y: -35 },
+      bottom: { x: 0, y: 35 },
+      left: { x: -65, y: 0 },
+      right: { x: 65, y: 0 },
+      in: { x: -65, y: 0 },
+      out: { x: 65, y: 0 }
+    }
+  },
+  sphere: {
+    width: 90,
+    height: 90,
+    ports: {
+      top: { x: 0, y: -45 },
+      bottom: { x: 0, y: 45 },
+      left: { x: -45, y: 0 },
+      right: { x: 45, y: 0 }
+    }
+  },
+  column_tray: {
+    width: 60,
+    height: 180,
+    ports: {
+      top: { x: 0, y: -90 },
+      bottom: { x: 0, y: 90 },
+      feed: { x: -30, y: 0 },
+      reflux: { x: 0, y: -90 },
+      bottom_return: { x: -30, y: 70 },
+      vapor_out: { x: 0, y: -90 },
+      liquid_out: { x: 0, y: 90 }
+    }
+  },
+  column_packed: {
+    width: 60,
+    height: 180,
+    ports: {
+      top: { x: 0, y: -90 },
+      bottom: { x: 0, y: 90 },
+      feed: { x: -30, y: 0 }
+    }
+  },
+  hx_shell_tube: {
+    width: 130,
+    height: 60,
+    ports: {
+      shell_in: { x: 0, y: -30 },
+      shell_out: { x: 0, y: 30 },
+      tube_in: { x: -65, y: 0 },
+      tube_out: { x: 65, y: 0 },
+      in: { x: -65, y: 0 },
+      out: { x: 65, y: 0 }
+    }
+  },
+  hx_air_cooled: {
+    width: 130,
+    height: 80,
+    ports: {
+      in: { x: -65, y: 10 },
+      out: { x: 65, y: 10 }
+    }
+  },
+  reboiler: {
+    width: 110,
+    height: 60,
+    ports: {
+      in: { x: -55, y: 0 },
+      out: { x: 55, y: 0 },
+      bottom: { x: 0, y: 30 }
+    }
+  },
+  condenser: {
+    width: 130,
+    height: 60,
+    ports: {
+      shell_in: { x: -50, y: -30 },
+      shell_out: { x: 50, y: 30 },
+      tube_in: { x: -65, y: 0 },
+      tube_out: { x: 65, y: 0 },
+      in: { x: -65, y: 0 },
+      out: { x: 65, y: 0 }
+    }
+  },
+  pump_centrifugal: {
+    width: 70,
+    height: 60,
+    ports: {
+      in: { x: -30, y: 0 },
+      out: { x: 28, y: -22 },
+      top: { x: 28, y: -22 },
+      left: { x: -30, y: 0 },
+      right: { x: 28, y: -22 }
+    }
+  },
+  pump_pd: {
+    width: 70,
+    height: 60,
+    ports: {
+      in: { x: -35, y: 0 },
+      out: { x: 35, y: 0 }
+    }
+  },
+  compressor: {
+    width: 90,
+    height: 60,
+    ports: {
+      in: { x: -45, y: 0 },
+      out: { x: 45, y: 0 }
+    }
+  },
+  blower: {
+    width: 70,
+    height: 60,
+    ports: {
+      in: { x: -35, y: 0 },
+      out: { x: 35, y: 0 }
+    }
+  },
+  reactor_cstr: {
+    width: 90,
+    height: 110,
+    ports: {
+      top: { x: 0, y: -55 },
+      bottom: { x: 0, y: 55 },
+      in: { x: -45, y: -10 },
+      out: { x: 0, y: 55 }
+    }
+  },
+  reactor_pfr: {
+    width: 130,
+    height: 50,
+    ports: {
+      in: { x: -65, y: 0 },
+      out: { x: 65, y: 0 }
+    }
+  },
+  filter: {
+    width: 70,
+    height: 70,
+    ports: {
+      in: { x: -35, y: 0 },
+      out: { x: 35, y: 0 }
+    }
+  },
+  cyclone: {
+    width: 70,
+    height: 100,
+    ports: {
+      top: { x: 0, y: -50 },
+      in: { x: -35, y: -30 },
+      bottom: { x: 0, y: 50 },
+      out: { x: 0, y: -50 }
+    }
+  },
+  flare: {
+    width: 30,
+    height: 110,
+    ports: {
+      top: { x: 0, y: -55 },
+      bottom: { x: 0, y: 55 },
+      in: { x: 0, y: 55 }
+    }
+  },
+  cooling_tower: {
+    width: 100,
+    height: 90,
+    ports: {
+      top: { x: 0, y: -45 },
+      in: { x: -50, y: 0 },
+      out: { x: 50, y: 0 }
+    }
+  },
+  // ── Valves (in-line) ──────────────────────────────────
+  valve_gate: {
+    width: 36,
+    height: 22,
+    ports: { in: { x: -18, y: 0 }, out: { x: 18, y: 0 }, left: { x: -18, y: 0 }, right: { x: 18, y: 0 } }
+  },
+  valve_ball: {
+    width: 36,
+    height: 22,
+    ports: { in: { x: -18, y: 0 }, out: { x: 18, y: 0 } }
+  },
+  valve_globe: {
+    width: 36,
+    height: 28,
+    ports: { in: { x: -18, y: 0 }, out: { x: 18, y: 0 } }
+  },
+  valve_butterfly: {
+    width: 36,
+    height: 22,
+    ports: { in: { x: -18, y: 0 }, out: { x: 18, y: 0 } }
+  },
+  valve_check: {
+    width: 36,
+    height: 22,
+    ports: { in: { x: -18, y: 0 }, out: { x: 18, y: 0 } }
+  },
+  valve_control: {
+    width: 36,
+    height: 60,
+    ports: { in: { x: -18, y: 12 }, out: { x: 18, y: 12 }, top: { x: 0, y: -22 } }
+  },
+  valve_psv: {
+    width: 36,
+    height: 60,
+    ports: { in: { x: -18, y: 12 }, out: { x: 18, y: -8 } }
+  }
+};
+var STROKE_BLACK = "#1d1d1d";
+var FILL_WHITE = "#ffffff";
+function bowtie() {
+  return polygon({
+    points: "-18,-11 0,0 -18,11 18,11 0,0 18,-11",
+    class: "lt-pid-valve-body"
+  });
+}
+function renderEquip(type, label) {
+  switch (type) {
+    case "tank_atm": {
+      const w = 90;
+      const h = 90;
+      const cylTop = -h / 2 + 14;
+      const parts = [
+        // dome top
+        path({
+          d: `M ${-w / 2} ${cylTop} A ${w / 2} 14 0 0 1 ${w / 2} ${cylTop}`,
+          class: "lt-pid-equip"
+        }),
+        // body
+        rect({
+          x: -w / 2,
+          y: cylTop,
+          width: w,
+          height: h - 14,
+          class: "lt-pid-equip"
+        }),
+        // tag
+        text(
+          { x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ];
+      return group({ class: "lt-pid-equip-group" }, parts);
+    }
+    case "tank_cone_roof": {
+      const w = 90;
+      const h = 100;
+      const roofH = 18;
+      const top = -h / 2;
+      return group({}, [
+        polygon({
+          points: `${-w / 2},${top + roofH} 0,${top} ${w / 2},${top + roofH}`,
+          class: "lt-pid-equip"
+        }),
+        rect({
+          x: -w / 2,
+          y: top + roofH,
+          width: w,
+          height: h - roofH,
+          class: "lt-pid-equip"
+        }),
+        text({ x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "vessel_v": {
+      const w = 70;
+      const h = 130;
+      const headH = 16;
+      const top = -h / 2;
+      const bot = h / 2;
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${top + headH}
+              A ${w / 2} ${headH} 0 0 1 ${w / 2} ${top + headH}
+              L ${w / 2} ${bot - headH}
+              A ${w / 2} ${headH} 0 0 1 ${-w / 2} ${bot - headH}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        text(
+          { x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "vessel_h": {
+      const w = 130;
+      const h = 70;
+      const headW = 14;
+      const left = -w / 2;
+      const right = w / 2;
+      return group({}, [
+        path({
+          d: `M ${left + headW} ${-h / 2}
+              L ${right - headW} ${-h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${right - headW} ${h / 2}
+              L ${left + headW} ${h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${left + headW} ${-h / 2}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        text(
+          { x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "sphere": {
+      return group({}, [
+        circle({ cx: 0, cy: 0, r: 45, class: "lt-pid-equip" }),
+        text({ x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "column_tray": {
+      const w = 60;
+      const h = 180;
+      const headH = 12;
+      const trays = 12;
+      const inner = h - headH * 2;
+      const traySpacing = inner / (trays + 1);
+      const trayLines = [];
+      for (let i = 1; i <= trays; i++) {
+        const y = -h / 2 + headH + traySpacing * i;
+        trayLines.push(
+          line({
+            x1: -w / 2 + 6,
+            y1: y,
+            x2: w / 2 - 6,
+            y2: y,
+            class: "lt-pid-tray-line"
+          })
+        );
+      }
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${-h / 2 + headH}
+              A ${w / 2} ${headH} 0 0 1 ${w / 2} ${-h / 2 + headH}
+              L ${w / 2} ${h / 2 - headH}
+              A ${w / 2} ${headH} 0 0 1 ${-w / 2} ${h / 2 - headH}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        ...trayLines,
+        text(
+          {
+            x: 0,
+            y: -h / 2 - 6,
+            "text-anchor": "middle",
+            class: "lt-pid-equip-tag"
+          },
+          label
+        )
+      ]);
+    }
+    case "column_packed": {
+      const w = 60;
+      const h = 180;
+      const headH = 12;
+      const packing = path({
+        d: `M ${-w / 2 + 6} ${-h / 2 + headH + 6}
+            L ${w / 2 - 6} ${h / 2 - headH - 6}
+            M ${w / 2 - 6} ${-h / 2 + headH + 6}
+            L ${-w / 2 + 6} ${h / 2 - headH - 6}`,
+        class: "lt-pid-tray-line"
+      });
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${-h / 2 + headH}
+              A ${w / 2} ${headH} 0 0 1 ${w / 2} ${-h / 2 + headH}
+              L ${w / 2} ${h / 2 - headH}
+              A ${w / 2} ${headH} 0 0 1 ${-w / 2} ${h / 2 - headH}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        packing,
+        text(
+          {
+            x: 0,
+            y: -h / 2 - 6,
+            "text-anchor": "middle",
+            class: "lt-pid-equip-tag"
+          },
+          label
+        )
+      ]);
+    }
+    case "hx_shell_tube": {
+      const w = 130;
+      const h = 60;
+      const headW = 12;
+      const left = -w / 2;
+      const right = w / 2;
+      const tubes = [];
+      for (let yy = -h / 2 + 12; yy <= h / 2 - 12; yy += 8) {
+        tubes.push(
+          line({
+            x1: left + headW + 4,
+            y1: yy,
+            x2: right - headW - 4,
+            y2: yy,
+            class: "lt-pid-tray-line"
+          })
+        );
+      }
+      return group({}, [
+        path({
+          d: `M ${left + headW} ${-h / 2}
+              L ${right - headW} ${-h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${right - headW} ${h / 2}
+              L ${left + headW} ${h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${left + headW} ${-h / 2}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        ...tubes,
+        text(
+          {
+            x: 0,
+            y: h / 2 + 14,
+            "text-anchor": "middle",
+            class: "lt-pid-equip-tag"
+          },
+          label
+        )
+      ]);
+    }
+    case "hx_air_cooled": {
+      const w = 130;
+      const h = 80;
+      return group({}, [
+        rect({
+          x: -w / 2,
+          y: -h / 2 + 18,
+          width: w,
+          height: h - 18,
+          class: "lt-pid-equip"
+        }),
+        circle({ cx: 0, cy: -h / 2 + 14, r: 18, class: "lt-pid-equip" }),
+        // 3-blade fan
+        path({
+          d: `M 0 ${-h / 2 + 14} L 14 ${-h / 2 + 6}
+              M 0 ${-h / 2 + 14} L -14 ${-h / 2 + 6}
+              M 0 ${-h / 2 + 14} L 0 ${-h / 2 + 30}`,
+          class: "lt-pid-tray-line"
+        }),
+        text(
+          { x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "reboiler": {
+      const w = 110;
+      const h = 60;
+      const headW = 14;
+      return group({}, [
+        path({
+          d: `M ${-w / 2 + headW} ${-h / 2}
+              L ${w / 2 - headW} ${-h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${w / 2 - headW} ${h / 2}
+              L ${-w / 2 + headW} ${h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${-w / 2 + headW} ${-h / 2}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        line({
+          x1: -w / 2 + headW + 4,
+          y1: -10,
+          x2: w / 2 - headW - 4,
+          y2: -10,
+          class: "lt-pid-tray-line"
+        }),
+        line({
+          x1: -w / 2 + headW + 4,
+          y1: 0,
+          x2: w / 2 - headW - 4,
+          y2: 0,
+          class: "lt-pid-tray-line"
+        }),
+        line({
+          x1: -w / 2 + headW + 4,
+          y1: 10,
+          x2: w / 2 - headW - 4,
+          y2: 10,
+          class: "lt-pid-tray-line"
+        }),
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "condenser": {
+      const w = 130;
+      const h = 60;
+      const headW = 12;
+      const left = -w / 2;
+      const right = w / 2;
+      const tubes = [];
+      for (let yy = -h / 2 + 12; yy <= h / 2 - 12; yy += 10) {
+        tubes.push(
+          line({
+            x1: left + headW + 4,
+            y1: yy,
+            x2: right - headW - 4,
+            y2: yy,
+            class: "lt-pid-tray-line"
+          })
+        );
+      }
+      return group({}, [
+        path({
+          d: `M ${left + headW} ${-h / 2}
+              L ${right - headW} ${-h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${right - headW} ${h / 2}
+              L ${left + headW} ${h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${left + headW} ${-h / 2}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        ...tubes,
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "pump_centrifugal": {
+      const r = 22;
+      return group({}, [
+        circle({ cx: 0, cy: 0, r, class: "lt-pid-equip" }),
+        polygon({
+          points: `${r * 0.4},${-r * 0.9} ${r + 6},${-r * 0.9} ${r * 0.4},${0}`,
+          class: "lt-pid-equip"
+        }),
+        text(
+          { x: 0, y: r + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "pump_pd": {
+      const r = 22;
+      return group({}, [
+        circle({ cx: 0, cy: 0, r, class: "lt-pid-equip" }),
+        circle({ cx: -8, cy: 0, r: 6, class: "lt-pid-tray-line", fill: "none" }),
+        circle({ cx: 8, cy: 0, r: 6, class: "lt-pid-tray-line", fill: "none" }),
+        text(
+          { x: 0, y: r + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "compressor": {
+      return group({}, [
+        polygon({
+          points: "-45,-20 45,-12 45,12 -45,20",
+          class: "lt-pid-equip"
+        }),
+        text({ x: 0, y: 36, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "blower": {
+      const r = 22;
+      return group({}, [
+        circle({ cx: 0, cy: 0, r, class: "lt-pid-equip" }),
+        path({
+          d: `M 0 0 L ${r * 0.8} ${-r * 0.5} M 0 0 L ${-r * 0.6} ${-r * 0.6} M 0 0 L 0 ${r * 0.8}`,
+          class: "lt-pid-tray-line"
+        }),
+        text({ x: 0, y: r + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "reactor_cstr": {
+      const w = 90;
+      const h = 110;
+      const headH = 14;
+      const top = -h / 2;
+      const bot = h / 2;
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${top + headH}
+              A ${w / 2} ${headH} 0 0 1 ${w / 2} ${top + headH}
+              L ${w / 2} ${bot - headH}
+              A ${w / 2} ${headH} 0 0 1 ${-w / 2} ${bot - headH}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        // agitator shaft + paddle
+        line({ x1: 0, y1: top - 14, x2: 0, y2: 4, class: "lt-pid-tray-line" }),
+        rect({ x: -10, y: 4, width: 20, height: 4, class: "lt-pid-equip" }),
+        text(
+          { x: 0, y: bot + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" },
+          label
+        )
+      ]);
+    }
+    case "reactor_pfr": {
+      const w = 130;
+      const h = 50;
+      const headW = 12;
+      const left = -w / 2;
+      const right = w / 2;
+      const dots = [];
+      for (let xx = left + headW + 8; xx <= right - headW - 8; xx += 12) {
+        for (let yy = -h / 2 + 12; yy <= h / 2 - 8; yy += 10) {
+          dots.push(circle({ cx: xx, cy: yy, r: 1.6, fill: STROKE_BLACK }));
+        }
+      }
+      return group({}, [
+        path({
+          d: `M ${left + headW} ${-h / 2}
+              L ${right - headW} ${-h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${right - headW} ${h / 2}
+              L ${left + headW} ${h / 2}
+              A ${headW} ${h / 2} 0 0 1 ${left + headW} ${-h / 2}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        ...dots,
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "filter": {
+      const w = 70;
+      const h = 70;
+      return group({}, [
+        rect({ x: -w / 2, y: -h / 2, width: w, height: h, class: "lt-pid-equip" }),
+        line({ x1: -w / 2, y1: 0, x2: w / 2, y2: 0, class: "lt-pid-tray-line" }),
+        line({ x1: -w / 2 + 8, y1: -h / 2 + 8, x2: w / 2 - 8, y2: -8, class: "lt-pid-tray-line" }),
+        line({ x1: -w / 2 + 8, y1: 8, x2: w / 2 - 8, y2: h / 2 - 8, class: "lt-pid-tray-line" }),
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "cyclone": {
+      const w = 70;
+      const h = 100;
+      const cyl = 30;
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${-h / 2}
+              L ${w / 2} ${-h / 2}
+              L ${w / 2} ${-h / 2 + cyl}
+              L 0 ${h / 2}
+              L ${-w / 2} ${-h / 2 + cyl}
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "flare": {
+      const w = 30;
+      const h = 110;
+      return group({}, [
+        rect({ x: -w / 2, y: -h / 2, width: w, height: h, class: "lt-pid-equip" }),
+        polygon({
+          points: `${ -8},${-h / 2 - 4} 0,${-h / 2 - 22} 8,${-h / 2 - 4}`,
+          fill: "#ff7755",
+          stroke: STROKE_BLACK
+        }),
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    case "cooling_tower": {
+      const w = 100;
+      const h = 90;
+      return group({}, [
+        path({
+          d: `M ${-w / 2} ${-h / 2}
+              L ${w / 2} ${-h / 2}
+              L ${w / 4} 0
+              L ${w / 2} ${h / 2}
+              L ${-w / 2} ${h / 2}
+              L ${-w / 4} 0
+              Z`,
+          class: "lt-pid-equip"
+        }),
+        text({ x: 0, y: h / 2 + 14, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    }
+    // ── Valves ──────────────────────────────────────────
+    case "valve_gate":
+      return group({}, [
+        bowtie(),
+        text({ x: 0, y: 22, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_ball":
+      return group({}, [
+        bowtie(),
+        circle({ cx: 0, cy: 0, r: 4, fill: STROKE_BLACK }),
+        text({ x: 0, y: 22, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_globe":
+      return group({}, [
+        bowtie(),
+        circle({ cx: 0, cy: -5, r: 5, class: "lt-pid-valve-body", fill: FILL_WHITE }),
+        text({ x: 0, y: 22, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_butterfly":
+      return group({}, [
+        bowtie(),
+        line({ x1: 0, y1: -10, x2: 0, y2: 10, class: "lt-pid-tray-line" }),
+        text({ x: 0, y: 22, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_check":
+      return group({}, [
+        bowtie(),
+        path({ d: "M -10 -8 A 10 10 0 0 1 -10 8", class: "lt-pid-tray-line", fill: "none" }),
+        text({ x: 0, y: 22, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_control":
+      return group({}, [
+        bowtie(),
+        // actuator: diaphragm
+        line({ x1: 0, y1: -11, x2: 0, y2: -22, class: "lt-pid-tray-line" }),
+        path({ d: "M -14 -22 A 14 8 0 0 1 14 -22 L -14 -22 Z", class: "lt-pid-equip" }),
+        text({ x: 0, y: 24, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    case "valve_psv":
+      return group({}, [
+        bowtie(),
+        // diagonal outlet (45°)
+        line({
+          x1: 18,
+          y1: -11,
+          x2: 26,
+          y2: -22,
+          class: "lt-pid-process"
+        }),
+        // spring stack
+        path({
+          d: "M -6 -11 L -10 -16 L -2 -20 L -10 -24 L -2 -28",
+          class: "lt-pid-tray-line",
+          fill: "none"
+        }),
+        text({ x: 0, y: 24, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+    default:
+      return group({}, [
+        rect({ x: -30, y: -20, width: 60, height: 40, class: "lt-pid-equip" }),
+        text({ x: 0, y: 4, "text-anchor": "middle", class: "lt-pid-equip-tag" }, label)
+      ]);
+  }
+}
+function renderInstrument(category, letterCode, loopNumber) {
+  const r = 14;
+  const isComputer = category.endsWith("computer");
+  const isPlc = category.endsWith("plc");
+  const isShared = category.endsWith("shared");
+  const isControlRoom = category.startsWith("cr_");
+  const isLocal = category.startsWith("local_");
+  const parts = [];
+  if (isComputer) {
+    parts.push(circle({ cx: 0, cy: 0, r, class: "lt-inst-body" }));
+    parts.push(
+      polygon({
+        points: `0,${-r + 1} ${r - 1},0 0,${r - 1} ${ -13},0`,
+        class: "lt-inst-body",
+        fill: "none"
+      })
+    );
+  } else if (isPlc) {
+    parts.push(circle({ cx: 0, cy: 0, r, class: "lt-inst-body" }));
+    const side = r * Math.SQRT1_2 * 2 - 2;
+    parts.push(
+      rect({
+        x: -side / 2,
+        y: -side / 2,
+        width: side,
+        height: side,
+        class: "lt-inst-body",
+        fill: "none"
+      })
+    );
+  } else if (isShared) {
+    parts.push(circle({ cx: 0, cy: 0, r, class: "lt-inst-body" }));
+    const hex = [];
+    for (let i = 0; i < 6; i++) {
+      const a = Math.PI / 3 * i - Math.PI / 2;
+      hex.push(`${(r - 2) * Math.cos(a)},${(r - 2) * Math.sin(a)}`);
+    }
+    parts.push(
+      polygon({
+        points: hex.join(" "),
+        class: "lt-inst-body",
+        fill: "none"
+      })
+    );
+  } else {
+    parts.push(circle({ cx: 0, cy: 0, r, class: "lt-inst-body" }));
+  }
+  if (isControlRoom) {
+    parts.push(line({ x1: -r, y1: 0, x2: r, y2: 0, class: "lt-inst-cr-line" }));
+  } else if (isLocal) {
+    parts.push(line({ x1: -r, y1: 0, x2: r, y2: 0, class: "lt-inst-local-line" }));
+  }
+  parts.push(
+    text(
+      {
+        x: 0,
+        y: -3,
+        "text-anchor": "middle",
+        class: "lt-inst-tag"
+      },
+      letterCode
+    )
+  );
+  parts.push(
+    text(
+      {
+        x: 0,
+        y: 9,
+        "text-anchor": "middle",
+        class: "lt-inst-tag"
+      },
+      loopNumber
+    )
+  );
+  return group({ class: "lt-inst-symbol" }, parts);
+}
+
+// src/diagrams/pid/layout.ts
+var PADDING = 30;
+var TITLE_AREA = 26;
+var EQUIP_GAP_X = 70;
+var INST_RADIUS = 14;
+var INST_OFFSET = 38;
+function defaultPort(direction, equip) {
+  if (equip.equipType === "tank_atm" || equip.equipType === "tank_cone_roof") {
+    return direction === "out" ? "bottom" : "top";
+  }
+  if (equip.equipType === "vessel_v" || equip.equipType === "column_tray" || equip.equipType === "column_packed") {
+    return direction === "out" ? "bottom" : "top";
+  }
+  return direction === "out" ? "out" : "in";
+}
+function resolveSide(port) {
+  if (port === "top" || port === "vapor_out" || port === "reflux") return "top";
+  if (port === "bottom" || port === "liquid_out" || port === "bottom_return") return "bottom";
+  if (port === "left" || port === "in" || port === "feed" || port === "tube_in" || port === "shell_in") return "left";
+  return "right";
+}
+function getAnchor(layoutEq, port, fallback) {
+  const ports = layoutEq.ports;
+  let key = port;
+  if (!key || !(key in ports)) {
+    key = defaultPort(fallback, layoutEq.equip);
+  }
+  const p = ports[key] ?? ports.right ?? ports.out ?? ports.left ?? ports.in;
+  if (!p) return { x: layoutEq.cx, y: layoutEq.cy, side: "right" };
+  return { x: p.x, y: p.y, side: resolveSide(key ?? "right") };
+}
+function manhattanPath(fromX, fromY, fromSide, toX, toY, toSide) {
+  const isHFrom = fromSide === "left" || fromSide === "right";
+  const isHTo = toSide === "left" || toSide === "right";
+  if (isHFrom && isHTo) {
+    const midX = (fromX + toX) / 2;
+    return {
+      d: `M ${fromX} ${fromY} L ${midX} ${fromY} L ${midX} ${toY} L ${toX} ${toY}`,
+      midX,
+      midY: (fromY + toY) / 2
+    };
+  }
+  if (!isHFrom && !isHTo) {
+    const midY = (fromY + toY) / 2;
+    return {
+      d: `M ${fromX} ${fromY} L ${fromX} ${midY} L ${toX} ${midY} L ${toX} ${toY}`,
+      midX: (fromX + toX) / 2,
+      midY
+    };
+  }
+  if (isHFrom) {
+    return {
+      d: `M ${fromX} ${fromY} L ${toX} ${fromY} L ${toX} ${toY}`,
+      midX: toX,
+      midY: (fromY + toY) / 2
+    };
+  }
+  return {
+    d: `M ${fromX} ${fromY} L ${fromX} ${toY} L ${toX} ${toY}`,
+    midX: (fromX + toX) / 2,
+    midY: toY
+  };
+}
+function layoutPid(ast) {
+  const equipment = [];
+  const equipById = /* @__PURE__ */ new Map();
+  const heights = ast.equipment.map((e) => GEOMETRY[e.equipType]?.height ?? 60);
+  const maxH = Math.max(...heights, 0);
+  const rowY = PADDING + TITLE_AREA + maxH / 2 + 30;
+  let cursorX = PADDING + 40;
+  for (const equip of ast.equipment) {
+    const geo = GEOMETRY[equip.equipType] ?? { width: 60, height: 40, ports: {} };
+    const cx = cursorX + geo.width / 2;
+    const cy = rowY;
+    const x = cx - geo.width / 2;
+    const y = cy - geo.height / 2;
+    const ports = {};
+    for (const [name, p] of Object.entries(geo.ports)) {
+      ports[name] = { x: cx + p.x, y: cy + p.y };
+    }
+    const layoutEq = {
+      equip,
+      x,
+      y,
+      width: geo.width,
+      height: geo.height,
+      cx,
+      cy,
+      ports
+    };
+    equipment.push(layoutEq);
+    equipById.set(equip.id, layoutEq);
+    cursorX += geo.width + EQUIP_GAP_X;
+  }
+  const instruments = [];
+  const instById = /* @__PURE__ */ new Map();
+  const crBandY = PADDING + TITLE_AREA + 40;
+  let crSlot = 0;
+  for (const inst of ast.instruments) {
+    let cx = 0;
+    let cy = 0;
+    if (inst.category.startsWith("cr_")) {
+      const tgt = inst.controls ?? inst.measures ?? "";
+      const tgtEq = equipById.get(tgt);
+      cx = tgtEq ? tgtEq.cx : PADDING + 80 + crSlot * (INST_RADIUS * 2 + 28);
+      cy = crBandY;
+      crSlot += 1;
+    } else if (inst.category.startsWith("local_")) {
+      cy = rowY + maxH / 2 + INST_OFFSET + INST_RADIUS;
+      const tgt = inst.measures ?? inst.controls ?? "";
+      const tgtEq = equipById.get(tgt);
+      cx = tgtEq ? tgtEq.cx : PADDING + 80;
+    } else {
+      cy = rowY + maxH / 2 + INST_OFFSET;
+      const tgt = inst.measures ?? inst.controls ?? "";
+      const tgtEq = equipById.get(tgt);
+      cx = tgtEq ? tgtEq.cx : PADDING + 80;
+    }
+    const lay = {
+      inst,
+      cx,
+      cy,
+      r: INST_RADIUS
+    };
+    instruments.push(lay);
+    instById.set(inst.tag, lay);
+  }
+  const sameRow = (a, b) => Math.abs(a.cy - b.cy) < INST_RADIUS && Math.abs(a.cx - b.cx) < INST_RADIUS * 2 + 8;
+  const sortedByX = [...instruments].sort((a, b) => a.cx - b.cx);
+  for (let i = 1; i < sortedByX.length; i++) {
+    const prev = sortedByX[i - 1];
+    const cur = sortedByX[i];
+    if (sameRow(prev, cur)) {
+      cur.cx = prev.cx + INST_RADIUS * 2 + 14;
+    }
+  }
+  const lines = [];
+  for (const ln of ast.lines) {
+    const path2 = routeLine(ln, equipById, instById);
+    if (path2) lines.push(path2);
+  }
+  const allX = [];
+  const allY = [];
+  for (const e of equipment) {
+    const tagPad = Math.max(0, ((e.equip.tag ?? e.equip.id).length * 6.6 - e.width) / 2 + 4);
+    allX.push(e.x - tagPad, e.x + e.width + tagPad);
+    allY.push(e.y, e.y + e.height + 30);
+  }
+  for (const i of instruments) {
+    allX.push(i.cx - i.r, i.cx + i.r);
+    allY.push(i.cy - i.r, i.cy + i.r + 14);
+  }
+  if (allX.length === 0) {
+    allX.push(0, 400);
+    allY.push(0, 200);
+  }
+  const maxX = Math.max(...allX);
+  const maxY = Math.max(...allY);
+  return {
+    width: Math.max(maxX + PADDING, 400),
+    height: Math.max(maxY + PADDING, 200),
+    equipment,
+    instruments,
+    lines,
+    title: ast.title
+  };
+}
+function routeLine(ln, equipById, instById) {
+  const fromAnchor = resolveAnchor(ln.from.id, ln.from.port, "out", equipById, instById);
+  const toAnchor = resolveAnchor(ln.to.id, ln.to.port, "in", equipById, instById);
+  if (!fromAnchor || !toAnchor) return void 0;
+  const { d, midX, midY } = manhattanPath(
+    fromAnchor.x,
+    fromAnchor.y,
+    fromAnchor.side,
+    toAnchor.x,
+    toAnchor.y,
+    toAnchor.side
+  );
+  return {
+    line: ln,
+    path: d,
+    midX,
+    midY
+  };
+}
+function resolveAnchor(id, port, fallback, equipById, instById) {
+  const eq = equipById.get(id);
+  if (eq) return getAnchor(eq, port, fallback);
+  const inst = instById.get(id);
+  if (inst) {
+    return {
+      x: inst.cx,
+      y: inst.cy,
+      side: fallback === "out" ? "right" : "left"
+    };
+  }
+  return void 0;
+}
+
+// src/diagrams/pid/renderer.ts
+var STYLE2 = `
+.lt-pid-equip { fill: #ffffff; stroke: #1d1d1d; stroke-width: 1.6; }
+.lt-pid-equip-tag { font: 600 11px system-ui, sans-serif; fill: #1d1d1d; }
+.lt-pid-tray-line { stroke: #555; stroke-width: 1; fill: none; }
+
+.lt-pid-process { stroke: #1d1d1d; stroke-width: 2.6; fill: none; }
+.lt-pid-process-min { stroke: #1d1d1d; stroke-width: 1.5; fill: none; }
+.lt-pid-pneumatic { stroke: #1d1d1d; stroke-width: 1.4; fill: none; }
+.lt-pid-electric { stroke: #1d1d1d; stroke-width: 1.4; fill: none; stroke-dasharray: 6 4; }
+.lt-pid-hydraulic { stroke: #1d1d1d; stroke-width: 1.4; fill: none; stroke-dasharray: 10 4; }
+.lt-pid-capillary { stroke: #1d1d1d; stroke-width: 1.4; fill: none; stroke-dasharray: 1 5; stroke-linecap: round; }
+.lt-pid-software { stroke: #6a6a6a; stroke-width: 1.3; fill: none; stroke-dasharray: 2 4; }
+.lt-pid-mechanical { stroke: #1d1d1d; stroke-width: 1.4; fill: none; stroke-dasharray: 3 2 1 2; }
+
+.lt-pid-pneumatic-tick { stroke: #1d1d1d; stroke-width: 1.2; }
+
+.lt-inst-body { fill: #ffffff; stroke: #1d1d1d; stroke-width: 1.4; }
+.lt-inst-tag { font: 600 9.5px system-ui, sans-serif; fill: #1d1d1d; }
+.lt-inst-cr-line { stroke: #1d1d1d; stroke-width: 1; }
+.lt-inst-local-line { stroke: #1d1d1d; stroke-width: 1; stroke-dasharray: 2 2; }
+.lt-pid-valve-body { fill: #ffffff; stroke: #1d1d1d; stroke-width: 1.4; }
+
+.lt-pid-line-tag-bg { fill: #ffffff; stroke: #1d1d1d; stroke-width: 0.6; }
+.lt-pid-line-tag-text { font: 9px ui-monospace, monospace; fill: #1d1d1d; }
+
+.lt-pid-title { font: 600 14px system-ui, sans-serif; fill: #1d1d1d; }
+`;
+var ARROW_ID = "lt-pid-arrow";
+function lineClass(t) {
+  return `lt-pid-${t.replace("_", "-")}`;
+}
+function renderLine(l) {
+  const cls = lineClass(l.line.lineType);
+  const parts = [
+    path({
+      d: l.path,
+      class: cls,
+      "data-line-id": l.line.id,
+      "data-service": l.line.service ?? ""
+    })
+  ];
+  if (l.line.lineType === "pneumatic") {
+    parts.push(...pneumaticTicks(l.path));
+  }
+  if (l.line.tag) {
+    const w = Math.max(28, l.line.tag.length * 6);
+    parts.push(
+      rect({
+        x: l.midX - w / 2,
+        y: l.midY - 8,
+        width: w,
+        height: 14,
+        rx: 2,
+        ry: 2,
+        class: "lt-pid-line-tag-bg"
+      })
+    );
+    parts.push(
+      text(
+        {
+          x: l.midX,
+          y: l.midY + 3,
+          "text-anchor": "middle",
+          class: "lt-pid-line-tag-text"
+        },
+        l.line.tag
+      )
+    );
+  }
+  return group({ class: "lt-pid-line", "data-id": l.line.id }, parts);
+}
+function pneumaticTicks(d) {
+  const tokens = d.match(/([MLC])\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/g) ?? [];
+  const points = [];
+  for (const t of tokens) {
+    const m = t.match(/[MLC]\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)/);
+    if (!m) continue;
+    points.push({ x: parseFloat(m[1]), y: parseFloat(m[2]) });
+  }
+  const ticks = [];
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const len = Math.hypot(dx, dy);
+    if (len < 12) continue;
+    const ux = dx / len;
+    const uy = dy / len;
+    const px = -uy;
+    const py = ux;
+    for (let s = 18; s < len; s += 26) {
+      const cx = a.x + ux * s;
+      const cy = a.y + uy * s;
+      ticks.push(
+        line({
+          x1: cx + px * 4 - ux * 4,
+          y1: cy + py * 4 - uy * 4,
+          x2: cx - px * 4 + ux * 4,
+          y2: cy - py * 4 + uy * 4,
+          class: "lt-pid-pneumatic-tick"
+        })
+      );
+    }
+  }
+  return ticks;
+}
+function renderPidAST(ast, _config) {
+  const layout = layoutPid(ast);
+  return renderLayout2(layout);
+}
+function renderLayout2(layout) {
+  const equipNodes = layout.equipment.map((eq) => {
+    const symbol = renderEquip(eq.equip.equipType, eq.equip.tag ?? eq.equip.id);
+    return group(
+      {
+        class: "lt-pid-equip-wrap",
+        "data-id": eq.equip.id,
+        "data-type": eq.equip.equipType,
+        transform: `translate(${eq.cx} ${eq.cy})`
+      },
+      [symbol]
+    );
+  });
+  const instNodes = layout.instruments.map((i) => {
+    const { letter, number } = parseTag(i.inst.tag);
+    return group(
+      {
+        class: "lt-inst",
+        "data-tag": i.inst.tag,
+        "data-category": i.inst.category,
+        transform: `translate(${i.cx} ${i.cy})`
+      },
+      [renderInstrument(i.inst.category, letter, number)]
+    );
+  });
+  const autoSignals = [];
+  for (const i of layout.instruments) {
+    if (i.inst.measures) {
+      const eq = layout.equipment.find((e) => e.equip.id === i.inst.measures);
+      if (eq) {
+        const ax = i.cx;
+        const ay = i.cy;
+        const bx = eq.cx;
+        const by = eq.cy + eq.height / 2;
+        autoSignals.push(
+          path({
+            d: `M ${ax} ${ay} L ${ax} ${by + 8} L ${bx} ${by + 8} L ${bx} ${by}`,
+            class: "lt-pid-electric"
+          })
+        );
+      }
+    }
+    if (i.inst.controls) {
+      const eq = layout.equipment.find((e) => e.equip.id === i.inst.controls);
+      if (eq) {
+        const ax = i.cx;
+        const ay = i.cy + i.r;
+        const bx = eq.cx;
+        const by = eq.y;
+        autoSignals.push(
+          path({
+            d: `M ${ax} ${ay} L ${bx} ${ay} L ${bx} ${by}`,
+            class: "lt-pid-pneumatic"
+          })
+        );
+      }
+    }
+  }
+  const titleNode = layout.title ? text({ x: 16, y: 22, class: "lt-pid-title" }, layout.title) : "";
+  return svgRoot(
+    {
+      width: layout.width,
+      height: layout.height,
+      viewBox: `0 0 ${layout.width} ${layout.height}`,
+      class: "lt-pid",
+      "data-diagram-type": "pid"
+    },
+    [
+      el("title", {}, escapeXml(`P&ID${layout.title ? " \u2014 " + layout.title : ""}`)),
+      el("desc", {}, "ISA-5.1 / ISO 10628 P&ID rendered by Schematex"),
+      defs([
+        el(
+          "marker",
+          {
+            id: ARROW_ID,
+            markerWidth: 10,
+            markerHeight: 10,
+            refX: 9,
+            refY: 3,
+            orient: "auto",
+            markerUnits: "strokeWidth"
+          },
+          [polygon({ points: "0,0 10,3 0,6", fill: "#1d1d1d" })]
+        ),
+        el("style", {}, STYLE2)
+      ]),
+      titleNode,
+      group({ class: "lt-pid-equipment" }, equipNodes),
+      group({ class: "lt-pid-lines" }, layout.lines.map(renderLine)),
+      group({ class: "lt-pid-signals" }, autoSignals),
+      group({ class: "lt-pid-instruments" }, instNodes)
+    ]
+  );
+}
+function parseTag(tag) {
+  const idx = tag.indexOf("-");
+  if (idx < 0) return { letter: tag, number: "" };
+  return { letter: tag.slice(0, idx), number: tag.slice(idx + 1) };
+}
+
+// src/diagrams/pid/index.ts
+var pid = {
+  type: "pid",
+  detect(text2) {
+    return /^\s*pid\b/i.test(text2);
+  },
+  parse: parsePid,
+  render(text2, config) {
+    const ast = parsePid(text2);
+    return renderPidAST(ast);
+  }
+};
+
 // src/diagrams/mindmap/inline.ts
 var RE_TASK = /^\[( |x|X)\]\s+(.*)$/;
 function tokenizeInline(raw) {
@@ -2901,7 +5699,7 @@ function parseMindmap(text2) {
 }
 
 // src/diagrams/mindmap/layout.ts
-var PADDING = 40;
+var PADDING2 = 40;
 var SIBLING_GAP = 18;
 var MAIN_GAP = 44;
 var UNDERLINE_GAP = 4;
@@ -3048,13 +5846,13 @@ function normalize(nodes) {
     minY = Math.min(minY, n.y - lh / 2);
     maxY = Math.max(maxY, n.y + lh / 2);
   }
-  const dx = PADDING - minX;
-  const dy = PADDING - minY;
+  const dx = PADDING2 - minX;
+  const dy = PADDING2 - minY;
   for (const n of nodes) {
     n.x += dx;
     n.y += dy;
   }
-  return { width: maxX - minX + PADDING * 2, height: maxY - minY + PADDING * 2 };
+  return { width: maxX - minX + PADDING2 * 2, height: maxY - minY + PADDING2 * 2 };
 }
 function underlineY(n) {
   return n.y + n.labelHeight / 2 - UNDERLINE_GAP / 2;
@@ -3182,7 +5980,7 @@ function paletteColor(theme, branchIndex) {
   if (branchIndex < 0) return theme.centralFill;
   return theme.branchPalette[branchIndex % theme.branchPalette.length];
 }
-function renderLine(line2, leftX, cy, fontSize, fontFamily, fontWeight, theme) {
+function renderLine2(line2, leftX, cy, fontSize, fontFamily, fontWeight, theme) {
   const baselineY = cy + fontSize * 0.35;
   const tspans = [];
   const decorations = [];
@@ -3297,7 +6095,7 @@ function tspan(attrs, content) {
   }
   return `<tspan ${pairs.join(" ")}>${escapeXml(content)}</tspan>`;
 }
-function renderNode(n, color, theme, fontFamily) {
+function renderNode2(n, color, theme, fontFamily) {
   const isRoot = n.node.depth === 0;
   const isMain = n.node.depth === 1;
   const fs = n.fontSize;
@@ -3312,7 +6110,7 @@ function renderNode(n, color, theme, fontFamily) {
   for (let i = 0; i < lineCount; i++) {
     const line2 = n.lines[i];
     const cy = topY + (i + 0.5) * lh;
-    const r = renderLine(line2, textLeft, cy, fs, fontFamily, weight, theme);
+    const r = renderLine2(line2, textLeft, cy, fs, fontFamily, weight, theme);
     decorations.push(...r.decorations);
     children.push(r.textElement);
   }
@@ -3363,7 +6161,7 @@ function renderMindmapAST(ast, themeName = "default", fontFamily = "system-ui, -
   const nodeSvgs = [];
   for (const n of layout.nodes) {
     const color = n.node.depth === 0 ? theme.centralFill : paletteColor(theme, n.branchIndex);
-    nodeSvgs.push(renderNode(n, color, theme, fontFamily));
+    nodeSvgs.push(renderNode2(n, color, theme, fontFamily));
   }
   const title2 = ast.title ?? tokensToPlainText(ast.root.tokens);
   return svgRoot(
@@ -4823,7 +7621,9 @@ var plugins = [
   matrix,
   orgchart,
   decisiontree,
-  timeline
+  timeline,
+  state,
+  pid
 ];
 function detectPlugin(text2, config) {
   if (config?.type) {
@@ -4855,6 +7655,6 @@ function render(text2, config) {
   return plugin.render(text2, renderConfig);
 }
 
-export { decisiontree, parse, render, timeline };
-//# sourceMappingURL=chunk-VPKCW4PB.js.map
-//# sourceMappingURL=chunk-VPKCW4PB.js.map
+export { decisiontree, parse, pid, render, state, timeline };
+//# sourceMappingURL=chunk-NNU4RGT3.js.map
+//# sourceMappingURL=chunk-NNU4RGT3.js.map