@pixerate/editor 0.55.0 → 0.56.0

package/dist/diagram/index.js

@@ -1,46 +1,121 @@
 import {
+  ARCH_METRICS,
+  C4_METRICS,
   CLASS_RELATIONS,
   ER_CARDINALITIES,
   ER_PATTERNS,
   FLOWCHART_SHAPES,
+  GANTT_CONFIG_KEYS,
+  GANTT_METRICS,
+  GANTT_TAGS,
   META_COMMENT_PREFIX,
   META_FRONTMATTER_KEY,
+  POINT_BOX,
+  QUADRANT_METRICS,
+  RADAR_CHART_BOX,
+  SEQUENCE_METRICS,
   STATE_SHAPES,
+  XY_CHART_BOX,
+  afterIds,
   applyEdit,
   applyEdits,
+  applyStatementEdit,
+  architectureAdapter,
+  architectureArrow,
+  architectureEdgeRoute,
+  architectureGrammar,
+  architectureLayout,
+  c4Adapter,
+  c4ArrowHead,
+  c4BoundaryText,
+  c4ElementGeometry,
+  c4ElementType,
+  c4Grammar,
+  c4Layout,
+  c4RelGeometry,
+  c4Stereotype,
   canonicalShape,
   classGrammar,
   createLineAdapter,
   createPassthroughAdapter,
+  createStatementAdapter,
   detectFamily,
   detectFamilyFromHeader,
+  dropMetaKeys,
   emptyMeta,
   erGrammar,
+  filterInPlace,
   flowchartAdapter,
+  formatAxis,
   formatChain,
+  formatGanttDate,
   formatLink,
   formatNode,
+  ganttAdapter,
+  ganttGeometry,
+  ganttGrammar,
   getDiagramAdapter,
+  getFamilyLayout,
+  gitGraphAdapter,
+  gitGraphGrammar,
+  indentOf,
   isMetaEmpty,
+  journeyAdapter,
+  journeyGrammar,
+  journeyLayout,
   mergeMeta,
+  mindmapAdapter,
+  mindmapGrammar,
   parseAttributes,
   parseChain,
   parseFlowchartSource,
+  parseGanttDate,
   parseLink,
   parseMembers,
   parseMermaid,
   parseStatement,
+  parseStatementDocument,
+  pieAdapter,
+  pieGrammar,
+  pointCentre,
+  pointPosition,
+  positionToData,
+  quadrantAdapter,
+  quadrantGeometry,
+  quadrantGrammar,
+  quadrantSpace,
+  quote,
   quoteLabelIfNeeded,
+  radarAdapter,
+  radarGrammar,
   registerDiagramAdapter,
+  registerFamilyLayout,
   relationFor,
+  renameMetaKey,
   resolveShape,
+  sequenceAdapter,
+  sequenceGeometry,
+  sequenceGrammar,
   serializeMermaid,
   serializeMeta,
+  serializeStatementDocument,
+  serviceLabelLines,
+  sharedFrameLayout,
+  slugId,
+  spaceInput,
+  splitOutsideQuotes,
   splitSource,
   splitStatements,
   stateGrammar,
-  supportTierOf
-} from "../chunk-WWJNC7SX.js";
+  supportTierOf,
+  timelineAdapter,
+  timelineGrammar,
+  timelineLayout,
+  uniqueId,
+  unquote,
+  xyChartAdapter,
+  xyChartGrammar
+} from "../chunk-WJSCGBJ2.js";
 import {
   PRESENCE_COLORS,
   PerformanceQueue,
@@ -114,17 +189,1151 @@ function headingText(line) {
   return text || void 0;
 }
 
+// src/diagram/families/pie.ts
+var pieUI = {
+  family: "pie",
+  title: "Pie chart",
+  shapes: [{ value: "slice", label: "Slice" }],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: false, label: "Group" },
+  labels: true,
+  nodeNoun: "Slice",
+  nextId: (g) => `slice${g.nodes.length + 1}`,
+  canDetach: false,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [{ key: "value", label: "Value", type: "number", min: 0 }],
+  diagramFields: [{ key: "showData", label: "Show values in legend", type: "boolean" }],
+  newNode: () => ({ label: "New slice", data: { value: 10 } })
+};
+
+// src/diagram/families/mindmap.ts
+var mindmapUI = {
+  family: "mindmap",
+  title: "Mind map",
+  shapes: [
+    { value: "text", label: "Topic" },
+    { value: "rounded", label: "Rounded" },
+    { value: "rect", label: "Square" },
+    { value: "circle", label: "Circle" },
+    { value: "odd", label: "Bang" },
+    { value: "stadium", label: "Cloud" },
+    { value: "hex", label: "Hexagon" }
+  ],
+  edgeKinds: [
+    { value: "branch", label: "Branch", arrowStart: "none", arrowEnd: "none", pattern: "solid" }
+  ],
+  patterns: [{ value: "solid", label: "Solid" }],
+  arrowHeads: [{ value: "none", label: "None" }],
+  groups: { supported: false, label: "Group" },
+  labels: true,
+  nodeNoun: "Topic",
+  edgeNoun: "Branch",
+  nextId: (g) => `topic${g.nodes.length + 1}`,
+  canDetach: false,
+  hierarchy: true,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [{ key: "icon", label: "Icon", type: "text", placeholder: "fa fa-book" }],
+  newNode: () => ({ label: "New topic" })
+};
+
+// src/diagram/families/quadrant.ts
+var quadrantUI = {
+  family: "quadrant",
+  title: "Quadrant chart",
+  shapes: [{ value: "point", label: "Point" }],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: false, label: "Quadrant" },
+  labels: true,
+  nodeNoun: "Point",
+  nextId: (g) => `point${g.nodes.length + 1}`,
+  canDetach: false,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [
+    { key: "x", label: "X", type: "number", min: 0, max: 1, step: 0.05 },
+    { key: "y", label: "Y", type: "number", min: 0, max: 1, step: 0.05 },
+    { key: "radius", label: "Radius", type: "number", min: 1 },
+    { key: "color", label: "Colour", type: "text", placeholder: "#ff9900" }
+  ],
+  diagramFields: [
+    { key: "xAxisLeft", label: "X axis (left)", type: "text" },
+    { key: "xAxisRight", label: "X axis (right)", type: "text" },
+    { key: "yAxisBottom", label: "Y axis (bottom)", type: "text" },
+    { key: "yAxisTop", label: "Y axis (top)", type: "text" }
+  ],
+  newNode: () => ({ label: "New point", data: { x: 0.5, y: 0.5 } })
+};
+
+// src/diagram/families/c4.ts
+var c4UI = {
+  family: "c4",
+  title: "C4 diagram",
+  shapes: [
+    { value: "c4-person", label: "Person" },
+    { value: "c4-person-ext", label: "External person" },
+    { value: "c4-system", label: "System" },
+    { value: "c4-system-ext", label: "External system" },
+    { value: "c4-container", label: "Container" },
+    { value: "c4-container-ext", label: "External container" },
+    { value: "c4-component", label: "Component" },
+    { value: "c4-component-ext", label: "External component" },
+    { value: "c4-db", label: "Database" },
+    { value: "c4-queue", label: "Queue" }
+  ],
+  edgeKinds: [
+    {
+      value: "Rel",
+      label: "Relation",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    },
+    {
+      value: "BiRel",
+      label: "Bidirectional",
+      arrowStart: "arrow_point",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    },
+    {
+      value: "Rel_Back",
+      label: "Reverse",
+      arrowStart: "arrow_point",
+      arrowEnd: "none",
+      pattern: "solid"
+    }
+  ],
+  patterns: [{ value: "solid", label: "Solid" }],
+  arrowHeads: [
+    { value: "none", label: "None" },
+    { value: "arrow_point", label: "Arrow" }
+  ],
+  groups: { supported: true, label: "Boundary" },
+  labels: true,
+  nodeNoun: "Element",
+  edgeNoun: "Relation",
+  nextId: (g) => {
+    const taken = /* @__PURE__ */ new Set([...g.nodes.map((n) => n.id), ...g.groups.map((x) => x.id)]);
+    let i = g.nodes.length + 1;
+    while (taken.has(`el${i}`)) i++;
+    return `el${i}`;
+  },
+  canDetach: true,
+  styling: false,
+  directions: false,
+  // Positions are Mermaid's own layout (plus where the user dragged): "Arrange"
+  // would pin a dagre layout Mermaid never draws.
+  // "Tidy up" resets dragged positions to Mermaid's own layout (the registered family layout).
+  arrange: true,
+  preview: false,
+  connectable: true,
+  nodeFields: [
+    { key: "tech", label: "Technology", type: "text" },
+    { key: "descr", label: "Description", type: "text" }
+  ],
+  edgeFields: [{ key: "tech", label: "Technology", type: "text" }],
+  newNode: () => ({ label: "New element" })
+};
+
+// src/diagram/families/architecture.ts
+var SIDE_OPTIONS = [
+  { value: "L", label: "Left" },
+  { value: "R", label: "Right" },
+  { value: "T", label: "Top" },
+  { value: "B", label: "Bottom" }
+];
+var architectureUI = {
+  family: "architecture",
+  title: "Architecture diagram",
+  shapes: [
+    { value: "arch-service", label: "Service" },
+    { value: "sm-circ", label: "Junction" }
+  ],
+  edgeKinds: [
+    { value: "--", label: "Line", arrowStart: "none", arrowEnd: "none", pattern: "solid" },
+    { value: "-->", label: "Arrow", arrowStart: "none", arrowEnd: "arrow_point", pattern: "solid" },
+    {
+      value: "<-->",
+      label: "Bidirectional",
+      arrowStart: "arrow_point",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    }
+  ],
+  patterns: [{ value: "solid", label: "Solid" }],
+  arrowHeads: [
+    { value: "none", label: "None" },
+    { value: "arrow_point", label: "Arrow" }
+  ],
+  groups: { supported: true, label: "Group" },
+  labels: true,
+  nodeNoun: "Service",
+  edgeNoun: "Connection",
+  nextId: (g) => {
+    const taken = /* @__PURE__ */ new Set([...g.nodes.map((n) => n.id), ...g.groups.map((x) => x.id)]);
+    let i = g.nodes.length + 1;
+    while (taken.has(`svc${i}`)) i++;
+    return `svc${i}`;
+  },
+  canDetach: true,
+  styling: false,
+  directions: false,
+  // Positions are Mermaid's own layout (plus where the user dragged): "Arrange"
+  // would pin a dagre layout Mermaid never draws.
+  // "Tidy up" resets dragged positions to Mermaid's own layout (the registered family layout).
+  arrange: true,
+  preview: false,
+  connectable: true,
+  nodeFields: [
+    {
+      key: "icon",
+      label: "Icon",
+      type: "select",
+      options: ["cloud", "database", "disk", "internet", "server"].map((v) => ({
+        value: v,
+        label: v
+      }))
+    }
+  ],
+  edgeFields: [
+    { key: "sourceSide", label: "From side", type: "select", options: SIDE_OPTIONS },
+    { key: "targetSide", label: "To side", type: "select", options: SIDE_OPTIONS }
+  ],
+  newNode: () => ({ label: "New service", data: { icon: "server" } })
+};
+
+// src/diagram/families/sequence.ts
+function nextParticipantId(graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = 1;
+  while (taken.has(`P${i}`)) i++;
+  return `P${i}`;
+}
+var kind = (value, label, pattern, arrowEnd, arrowStart = "none") => ({ value, label, pattern, arrowStart, arrowEnd });
+var sequenceUI = {
+  family: "sequence",
+  title: "Sequence diagram",
+  shapes: [
+    { value: "rect", label: "Participant" },
+    { value: "actor", label: "Actor" }
+  ],
+  edgeKinds: [
+    kind("->>", "Sync", "solid", "arrow_point"),
+    kind("-->>", "Reply", "dotted", "arrow_point"),
+    kind("->", "Line", "solid", "none"),
+    kind("-->", "Dotted line", "dotted", "none"),
+    kind("-x", "Lost", "solid", "arrow_cross"),
+    kind("--x", "Dotted lost", "dotted", "arrow_cross"),
+    kind("-)", "Async", "solid", "arrow_open"),
+    kind("--)", "Dotted async", "dotted", "arrow_open"),
+    kind("<<->>", "Bidirectional", "solid", "arrow_point", "arrow_point")
+  ],
+  patterns: [
+    { value: "solid", label: "Solid" },
+    { value: "dotted", label: "Dotted" }
+  ],
+  arrowHeads: [
+    { value: "none", label: "None" },
+    { value: "arrow_point", label: "Arrow" },
+    { value: "arrow_cross", label: "Cross" },
+    { value: "arrow_open", label: "Open" }
+  ],
+  groups: { supported: true, label: "Box" },
+  labels: true,
+  nodeNoun: "Participant",
+  edgeNoun: "Message",
+  nextId: nextParticipantId,
+  canDetach: true,
+  styling: false,
+  directions: false,
+  arrange: false,
+  endpoints: true,
+  preview: false,
+  edgeFields: [
+    { key: "activate", label: "Activate target", type: "boolean" },
+    { key: "deactivate", label: "Deactivate source", type: "boolean" },
+    { key: "index", label: "Position (0 = first)", type: "number", min: 0 }
+  ],
+  diagramFields: [{ key: "autonumber", label: "Number messages", type: "boolean" }],
+  newNode: () => ({ label: "New participant" })
+};
+
+// src/diagram/families/gitgraph.ts
+function nextCommitId(graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = graph.nodes.length + 1;
+  while (taken.has(`commit${i}`)) i++;
+  return `commit${i}`;
+}
+var gitGraphUI = {
+  family: "gitGraph",
+  title: "Git graph",
+  shapes: [{ value: "commit", label: "Commit" }],
+  edgeKinds: [
+    {
+      value: "parent",
+      label: "Parent",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    }
+  ],
+  patterns: [{ value: "solid", label: "Solid" }],
+  arrowHeads: [{ value: "arrow_point", label: "Arrow" }],
+  groups: { supported: true, label: "Branch" },
+  labels: true,
+  nodeNoun: "Commit",
+  edgeNoun: "Parent link",
+  nextId: nextCommitId,
+  canDetach: false,
+  styling: false,
+  connectable: true,
+  directions: true,
+  groupDirections: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [
+    { key: "tag", label: "Tag", type: "text" },
+    {
+      key: "type",
+      label: "Type",
+      type: "select",
+      options: [
+        { value: "NORMAL", label: "Normal" },
+        { value: "REVERSE", label: "Reverse" },
+        { value: "HIGHLIGHT", label: "Highlight" }
+      ]
+    },
+    { key: "msg", label: "Message", type: "text" }
+  ],
+  newNode: () => ({ label: "New commit" })
+};
+
+// src/diagram/families/gantt.ts
+function nextTaskId(graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = graph.nodes.length + 1;
+  while (taken.has(`task${i}`)) i++;
+  return `task${i}`;
+}
+function newTaskStart(graph) {
+  const format = typeof graph.data?.dateFormat === "string" ? graph.data.dateFormat : void 0;
+  const ends = graph.nodes.map((n) => n.data?.endTime).filter((t) => typeof t === "number" && Number.isFinite(t));
+  if (ends.length) return formatGanttDate(Math.max(...ends), format);
+  const starts = graph.nodes.map((n) => n.data?.startTime).filter((t) => typeof t === "number" && Number.isFinite(t));
+  if (starts.length) return formatGanttDate(Math.min(...starts), format);
+  return "2026-01-01";
+}
+var ganttUI = {
+  family: "gantt",
+  title: "Gantt chart",
+  shapes: [
+    { value: "task", label: "Task" },
+    { value: "milestone", label: "Milestone" }
+  ],
+  edgeKinds: [
+    {
+      value: "depends",
+      label: "Depends on",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    }
+  ],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: true, label: "Section" },
+  labels: true,
+  nodeNoun: "Task",
+  edgeNoun: "Dependency",
+  nextId: nextTaskId,
+  canDetach: true,
+  styling: false,
+  // Connecting A → B writes `after A` into B's start.
+  connectable: true,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [
+    { key: "start", label: "Start", type: "text", placeholder: "2026-10-01 or after ds" },
+    { key: "end", label: "End or duration", type: "text", placeholder: "14d" },
+    {
+      key: "tags",
+      label: "Tags",
+      type: "tags",
+      hint: "done, active, crit, milestone, vert",
+      options: GANTT_TAGS.map((t) => ({ value: t, label: t }))
+    },
+    { key: "id", label: "Task id", type: "text" }
+  ],
+  diagramFields: [
+    { key: "dateFormat", label: "Date format", type: "text", placeholder: "YYYY-MM-DD" },
+    { key: "axisFormat", label: "Axis format", type: "text", placeholder: "%b %d" },
+    { key: "excludes", label: "Excludes", type: "text", placeholder: "weekends" },
+    { key: "tickInterval", label: "Tick interval", type: "text", placeholder: "1week" },
+    { key: "todayMarker", label: "Today marker", type: "text", placeholder: "off" }
+  ],
+  newNode: (graph) => ({
+    label: "New task",
+    shape: "task",
+    data: { start: newTaskStart(graph), end: "7d" }
+  })
+};
+
+// src/diagram/families/timeline.ts
+function nextPeriodId(graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = graph.nodes.length + 1;
+  while (taken.has(`period${i}`)) i++;
+  return `period${i}`;
+}
+var timelineUI = {
+  family: "timeline",
+  title: "Timeline",
+  shapes: [{ value: "rounded", label: "Period" }],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: true, label: "Section" },
+  labels: true,
+  nodeNoun: "Period",
+  nextId: nextPeriodId,
+  canDetach: true,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [{ key: "events", label: "Events (one per line)", type: "lines" }],
+  newNode: () => ({ label: "New period", shape: "rounded", data: { events: ["Event"] } })
+};
+
+// src/diagram/families/journey.ts
+function nextTaskId2(graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = graph.nodes.length + 1;
+  while (taken.has(`task${i}`)) i++;
+  return `task${i}`;
+}
+var journeyUI = {
+  family: "journey",
+  title: "User journey",
+  shapes: [{ value: "rect", label: "Task" }],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: true, label: "Section" },
+  labels: true,
+  nodeNoun: "Task",
+  nextId: nextTaskId2,
+  canDetach: true,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [
+    { key: "score", label: "Score", type: "number", min: 1, max: 5, step: 1 },
+    { key: "actors", label: "Actors", type: "tags" }
+  ],
+  newNode: () => ({ label: "New task", shape: "rect", data: { score: 3, actors: [] } })
+};
+
+// src/diagram/families/xychart.ts
+var xyChartUI = {
+  family: "xychart",
+  title: "XY chart",
+  shapes: [
+    { value: "bar", label: "Bar" },
+    { value: "line", label: "Line" }
+  ],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: false, label: "Group" },
+  labels: true,
+  nodeNoun: "Series",
+  nextId: (g) => `series${g.nodes.length + 1}`,
+  canDetach: false,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [
+    { key: "values", label: "Values", type: "numbers", hint: "One per x-axis category" }
+  ],
+  diagramFields: [
+    { key: "categories", label: "X-axis categories", type: "lines", placeholder: "One per line" },
+    { key: "xTitle", label: "X-axis title", type: "text" },
+    { key: "yTitle", label: "Y-axis title", type: "text" },
+    { key: "yMin", label: "Y-axis min", type: "number" },
+    { key: "yMax", label: "Y-axis max", type: "number" },
+    { key: "horizontal", label: "Horizontal", type: "boolean" }
+  ],
+  newNode: () => ({ label: "New series", shape: "bar" })
+};
+
+// src/diagram/families/radar.ts
+var radarUI = {
+  family: "radar",
+  title: "Radar chart",
+  shapes: [{ value: "curve", label: "Curve" }],
+  edgeKinds: [],
+  patterns: [],
+  arrowHeads: [],
+  groups: { supported: false, label: "Group" },
+  labels: true,
+  nodeNoun: "Curve",
+  nextId: (g) => {
+    const taken = new Set(g.nodes.map((n) => n.id));
+    let i = g.nodes.length + 1;
+    while (taken.has(`curve${i}`)) i++;
+    return `curve${i}`;
+  },
+  canDetach: false,
+  styling: false,
+  connectable: false,
+  directions: false,
+  arrange: false,
+  preview: false,
+  nodeFields: [{ key: "values", label: "Values", type: "numbers", hint: "One per axis" }],
+  diagramFields: [
+    { key: "axes", label: "Axes", type: "lines", placeholder: "One per line" },
+    { key: "max", label: "Max", type: "number" },
+    { key: "min", label: "Min", type: "number" },
+    { key: "ticks", label: "Ticks", type: "number", min: 1 },
+    {
+      key: "graticule",
+      label: "Grid",
+      type: "select",
+      options: [
+        { value: "circle", label: "Circles" },
+        { value: "polygon", label: "Polygons" }
+      ]
+    },
+    { key: "showLegend", label: "Show legend", type: "boolean" }
+  ],
+  newNode: () => ({ label: "New curve" })
+};
+
+// src/diagram/families/fields.ts
+function describeFields(fields) {
+  return (fields ?? []).map((f) => ({
+    key: f.key,
+    label: f.label,
+    type: f.type,
+    ...f.options ? { options: f.options.map((o) => o.value) } : {},
+    ...f.min !== void 0 ? { min: f.min } : {},
+    ...f.max !== void 0 ? { max: f.max } : {},
+    ...f.hint ? { hint: f.hint } : {},
+    ...f.shapes ? { shapes: f.shapes } : {}
+  }));
+}
+function pickFieldData(fields, data) {
+  const out = {};
+  for (const f of fields ?? []) {
+    const value = data?.[f.key];
+    if (value !== void 0 && value !== null && !(Array.isArray(value) && !value.length)) out[f.key] = value;
+  }
+  return out;
+}
+var list = (items) => items.map((s) => `"${s}"`).join(", ");
+function checkFieldData(fields, data, what, shape) {
+  const all = fields ?? [];
+  const usable = all.filter((f) => !f.shapes || shape === void 0 || f.shapes.includes(shape));
+  if (!all.length) throw new Error(`${what} has no data fields to set.`);
+  const keys = Object.keys(data);
+  if (!keys.length) throw new Error(`Give at least one field to set; ${what} has ${list(usable.map((f) => f.key))}.`);
+  const out = {};
+  for (const key of keys) {
+    const field = all.find((f) => f.key === key);
+    if (!field) throw new Error(`Unknown field "${key}" for ${what}; use one of ${list(usable.map((f) => f.key))}.`);
+    if (!usable.includes(field))
+      throw new Error(`Field "${key}" only applies to ${list(field.shapes)} nodes, not "${shape}".`);
+    const value = data[key];
+    if (value === null || value === "") {
+      out[key] = void 0;
+      continue;
+    }
+    const bad = (expected) => new Error(`Field "${key}" (${field.label}) takes ${expected}; got ${JSON.stringify(value)}.`);
+    switch (field.type) {
+      case "number": {
+        if (typeof value !== "number" || !Number.isFinite(value)) throw bad("a number");
+        if (field.min !== void 0 && value < field.min) throw bad(`a number of at least ${field.min}`);
+        if (field.max !== void 0 && value > field.max) throw bad(`a number of at most ${field.max}`);
+        break;
+      }
+      case "numbers":
+        if (!Array.isArray(value) || !value.every((n) => typeof n === "number" && Number.isFinite(n))) throw bad("an array of numbers");
+        break;
+      case "lines":
+      case "tags":
+        if (!Array.isArray(value) || !value.every((s) => typeof s === "string")) throw bad("an array of strings");
+        break;
+      case "boolean":
+        if (typeof value !== "boolean") throw bad("true or false");
+        break;
+      case "select": {
+        const options = (field.options ?? []).map((o) => o.value);
+        if (typeof value !== "string" || options.length && !options.includes(value)) throw bad(`one of ${list(options)}`);
+        break;
+      }
+      default:
+        if (typeof value !== "string") throw bad("a string");
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
+// src/diagram/families/index.ts
+function counterId(prefix, graph) {
+  const taken = /* @__PURE__ */ new Set([...graph.nodes.map((n) => n.id), ...graph.groups.map((g) => g.id)]);
+  let i = graph.nodes.length + 1;
+  while (taken.has(`${prefix}${i}`)) i++;
+  return `${prefix}${i}`;
+}
+var FLOW_HEADS = [
+  { value: "none", label: "None" },
+  { value: "arrow_point", label: "Arrow" },
+  { value: "arrow_circle", label: "Circle" },
+  { value: "arrow_cross", label: "Cross" }
+];
+var IMAGE_FIELDS = [
+  {
+    key: "img",
+    label: "Image URL",
+    type: "text",
+    placeholder: "https://\u2026/picture.png",
+    shapes: ["image"]
+  },
+  {
+    key: "pos",
+    label: "Label",
+    type: "select",
+    options: [
+      { value: "b", label: "Below" },
+      { value: "t", label: "Above" }
+    ],
+    shapes: ["image"]
+  },
+  { key: "w", label: "Width", type: "number", min: 8, step: 1, shapes: ["image"] },
+  { key: "h", label: "Height", type: "number", min: 8, step: 1, shapes: ["image"] },
+  {
+    key: "constraint",
+    label: "Keep aspect ratio",
+    type: "select",
+    options: [
+      { value: "on", label: "On" },
+      { value: "off", label: "Off" }
+    ],
+    shapes: ["image"]
+  }
+];
+var flowchartUI = {
+  family: "flowchart",
+  nodeFields: IMAGE_FIELDS,
+  title: "Flowchart",
+  shapes: FLOWCHART_SHAPES.map((s) => ({ value: s.name, label: s.title, category: s.category })),
+  edgeKinds: [
+    {
+      value: "arrow",
+      label: "Arrow",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    },
+    { value: "open", label: "Line", arrowStart: "none", arrowEnd: "none", pattern: "solid" },
+    {
+      value: "dotted",
+      label: "Dotted arrow",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "dotted"
+    },
+    {
+      value: "thick",
+      label: "Thick arrow",
+      arrowStart: "none",
+      arrowEnd: "arrow_point",
+      pattern: "thick"
+    },
+    {
+      value: "bidir",
+      label: "Bidirectional",
+      arrowStart: "arrow_point",
+      arrowEnd: "arrow_point",
+      pattern: "solid"
+    },
+    {
+      value: "invisible",
+      label: "Invisible (layout)",
+      arrowStart: "none",
+      arrowEnd: "none",
+      pattern: "invisible"
+    }
+  ],
+  patterns: [
+    { value: "solid", label: "Solid" },
+    { value: "dotted", label: "Dotted" },
+    { value: "thick", label: "Thick" },
+    { value: "invisible", label: "Invisible" }
+  ],
+  arrowHeads: FLOW_HEADS,
+  groups: { supported: true, label: "Subgraph" },
+  labels: true,
+  nodeNoun: "Node",
+  nextId: (g) => counterId("n", g),
+  canDetach: false
+};
+var stateUI = {
+  family: "state",
+  title: "State diagram",
+  shapes: [
+    { value: "rect", label: "State" },
+    { value: "choice", label: "Choice" },
+    { value: "fork", label: "Fork" },
+    { value: "join", label: "Join" }
+  ],
+  edgeKinds: [
+    {
+      value: "transition",
+      label: "Transition",
+      arrowStart: "none",
+      arrowEnd: "arrow_barb",
+      pattern: "solid"
+    }
+  ],
+  patterns: [{ value: "solid", label: "Solid" }],
+  arrowHeads: [{ value: "arrow_barb", label: "Arrow" }],
+  groups: { supported: true, label: "Composite state" },
+  labels: true,
+  nodeNoun: "State",
+  nextId: (g) => counterId("State", g),
+  canDetach: true
+};
+var classUI = {
+  family: "class",
+  title: "Class diagram",
+  shapes: [{ value: "classBox", label: "Class" }],
+  edgeKinds: CLASS_RELATIONS.filter((r) => !r.title.includes("reversed")).map((r) => ({
+    value: r.token,
+    label: r.title,
+    arrowStart: r.arrowStart,
+    arrowEnd: r.arrowEnd,
+    pattern: r.pattern
+  })),
+  patterns: [
+    { value: "solid", label: "Solid" },
+    { value: "dotted", label: "Dashed" }
+  ],
+  arrowHeads: [
+    { value: "none", label: "None" },
+    { value: "extension", label: "Inheritance" },
+    { value: "composition", label: "Composition" },
+    { value: "aggregation", label: "Aggregation" },
+    { value: "dependency", label: "Arrow" },
+    { value: "lollipop", label: "Lollipop" }
+  ],
+  groups: { supported: true, label: "Namespace" },
+  labels: true,
+  nodeNoun: "Class",
+  nextId: (g) => counterId("Class", g),
+  canDetach: true
+};
+var erUI = {
+  family: "er",
+  title: "Entity relationship",
+  shapes: [{ value: "erBox", label: "Entity" }],
+  edgeKinds: [
+    {
+      value: "one-many",
+      label: "One to many",
+      arrowStart: "only_one",
+      arrowEnd: "zero_or_more",
+      pattern: "solid"
+    },
+    {
+      value: "one-one",
+      label: "One to one",
+      arrowStart: "only_one",
+      arrowEnd: "only_one",
+      pattern: "solid"
+    },
+    {
+      value: "many-many",
+      label: "Many to many",
+      arrowStart: "zero_or_more",
+      arrowEnd: "zero_or_more",
+      pattern: "solid"
+    },
+    {
+      value: "one-many-ni",
+      label: "One to many (non-identifying)",
+      arrowStart: "only_one",
+      arrowEnd: "zero_or_more",
+      pattern: "dotted"
+    }
+  ],
+  patterns: [
+    { value: "solid", label: "Identifying" },
+    { value: "dotted", label: "Non-identifying" }
+  ],
+  arrowHeads: Array.from(
+    new Map(ER_CARDINALITIES.map((c) => [c.head, { value: c.head, label: c.title }])).values()
+  ),
+  groups: { supported: false, label: "Group" },
+  labels: true,
+  nodeNoun: "Entity",
+  nextId: (g) => counterId("ENTITY_", g),
+  canDetach: true
+};
+var FAMILY_UI = {
+  flowchart: flowchartUI,
+  state: stateUI,
+  class: classUI,
+  er: erUI,
+  pie: pieUI,
+  mindmap: mindmapUI,
+  quadrant: quadrantUI,
+  c4: c4UI,
+  architecture: architectureUI,
+  sequence: sequenceUI,
+  gitGraph: gitGraphUI,
+  gantt: ganttUI,
+  timeline: timelineUI,
+  journey: journeyUI,
+  xychart: xyChartUI,
+  radar: radarUI
+};
+function familyUI(family) {
+  return FAMILY_UI[family] ?? null;
+}
+var FAMILY_TITLES = {
+  flowchart: "Flowchart",
+  state: "State diagram",
+  class: "Class diagram",
+  er: "Entity relationship",
+  requirement: "Requirement diagram",
+  mindmap: "Mind map",
+  sequence: "Sequence diagram",
+  gantt: "Gantt chart",
+  pie: "Pie chart",
+  journey: "User journey",
+  timeline: "Timeline",
+  gitGraph: "Git graph",
+  c4: "C4 diagram",
+  quadrant: "Quadrant chart",
+  sankey: "Sankey diagram",
+  xychart: "XY chart",
+  block: "Block diagram",
+  architecture: "Architecture diagram",
+  packet: "Packet diagram",
+  kanban: "Kanban board",
+  radar: "Radar chart",
+  treemap: "Treemap",
+  info: "Info",
+  unknown: "Unknown diagram"
+};
+var FAMILY_TEMPLATES = {
+  flowchart: "flowchart TD\n  A[Start] --> B{Decision}\n  B -->|Yes| C[Do it]\n  B -->|No| D[Skip]\n  C --> E[End]\n  D --> E\n",
+  state: "stateDiagram-v2\n  [*] --> Idle\n  Idle --> Active : start\n  Active --> Idle : stop\n  Active --> [*] : finish\n",
+  class: 'classDiagram\n  class Account {\n    +String id\n    +deposit(amount)\n  }\n  class Customer\n  Customer "1" --> "*" Account : owns\n',
+  er: "erDiagram\n  CUSTOMER ||--o{ ORDER : places\n  ORDER ||--|{ LINE_ITEM : contains\n  CUSTOMER {\n    string name PK\n    string email\n  }\n",
+  sequence: "sequenceDiagram\n  participant U as User\n  participant S as Service\n  U->>S: Request\n  S-->>U: Response\n",
+  pie: 'pie showData\n  title Share by segment\n  "Segment A" : 40\n  "Segment B" : 35\n  "Segment C" : 25\n',
+  mindmap: "mindmap\n  root((Central idea))\n    Topic A\n      Detail\n    Topic B\n    Topic C\n",
+  timeline: "timeline\n  title Milestones\n  2024 : First release\n  2025 : Second release\n       : Expansion\n  2026 : Next chapter\n",
+  journey: "journey\n  title Customer journey\n  section Discover\n    Find the product: 3: Customer\n  section Buy\n    Check out: 4: Customer\n    Confirm order: 5: Customer, Support\n",
+  gantt: "gantt\n  title Plan\n  dateFormat YYYY-MM-DD\n  section Phase 1\n    Research :a1, 2026-01-05, 10d\n    Design :a2, after a1, 7d\n  section Phase 2\n    Build :a3, after a2, 14d\n",
+  gitGraph: 'gitGraph\n  commit id: "init"\n  branch develop\n  checkout develop\n  commit id: "feature"\n  checkout main\n  merge develop tag: "v1.0"\n',
+  c4: 'C4Context\n  title System context\n  Person(user, "User", "Uses the system")\n  System(sys, "System", "Does the work")\n  System_Ext(ext, "External service", "Provides data")\n  Rel(user, sys, "Uses")\n  Rel(sys, ext, "Calls")\n',
+  architecture: "architecture-beta\n  group app(cloud)[Application]\n  service web(server)[Web] in app\n  service db(database)[Database] in app\n  service edge(internet)[Edge]\n  edge:R --> L:web\n  web:B --> T:db\n",
+  quadrant: "quadrantChart\n  title Prioritisation\n  x-axis Low effort --> High effort\n  y-axis Low value --> High value\n  quadrant-1 Plan\n  quadrant-2 Do first\n  quadrant-3 Drop\n  quadrant-4 Fill-ins\n  Idea A: [0.3, 0.8]\n  Idea B: [0.7, 0.6]\n  Idea C: [0.2, 0.3]\n",
+  xychart: 'xychart-beta\n  title "Monthly sales"\n  x-axis [Jan, Feb, Mar, Apr]\n  y-axis "Units" 0 --> 100\n  bar [42, 58, 71, 64]\n  line "Target" [50, 55, 60, 65]\n',
+  radar: 'radar-beta\n  title Option comparison\n  axis cost["Cost"], speed["Speed"], quality["Quality"], risk["Risk"]\n  curve a["Option A"]{80, 60, 90, 40}\n  curve b["Option B"]{50, 90, 60, 70}\n  max 100\n'
+};
+var FAMILY_BLANKS = {
+  flowchart: "flowchart TD\n",
+  state: "stateDiagram-v2\n",
+  class: "classDiagram\n  direction TB\n",
+  er: "erDiagram\n",
+  sequence: "sequenceDiagram\n",
+  pie: "pie\n",
+  mindmap: "mindmap\n",
+  timeline: "timeline\n",
+  journey: "journey\n",
+  gantt: "gantt\n  dateFormat YYYY-MM-DD\n",
+  gitGraph: "gitGraph\n",
+  c4: "C4Context\n  title System context\n",
+  architecture: "architecture-beta\n",
+  quadrant: "quadrantChart\n",
+  xychart: "xychart-beta\n",
+  radar: "radar-beta\n"
+};
+var FAMILY_DESCRIPTIONS = {
+  flowchart: "Steps, decisions and the paths between them.",
+  state: "The states something moves through and what triggers each change.",
+  class: "Types with their fields and methods, and how they relate.",
+  er: "Entities, their attributes and the relationships between them.",
+  sequence: "Messages exchanged between participants over time.",
+  pie: "Parts of a whole as slices.",
+  mindmap: "Ideas branching out from a central topic.",
+  timeline: "Events grouped by period, in order.",
+  journey: "A user's tasks, section by section, scored by how they feel.",
+  gantt: "Tasks on a calendar with durations and dependencies.",
+  gitGraph: "Branches, commits and merges of a repository.",
+  c4: "People and software systems, and how they interact.",
+  architecture: "Services and infrastructure grouped by where they run.",
+  quadrant: "Items placed on two axes in four quadrants.",
+  xychart: "Bars and lines over categories or a numeric axis.",
+  radar: "Scores across several axes, one curve per item compared."
+};
+
+// src/diagram/sankey/index.ts
+function parseSankey(source) {
+  const split = splitSource(source);
+  if (!/^\s*sankey(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a sankey diagram: the first line should be `sankey-beta`." };
+  }
+  const firstLine = split.headerIndex + 2;
+  const kept = [];
+  split.bodyLines.forEach((text, i) => {
+    if (/^\s*%%/.test(text)) return;
+    kept.push({ text: text.trim(), line: firstLine + i });
+  });
+  const records = readRecords(kept);
+  if ("error" in records) return records;
+  const nodes = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (name) => {
+    if (!seen.has(name)) {
+      seen.add(name);
+      nodes.push(name);
+    }
+  };
+  const links = [];
+  for (const { fields, line } of records) {
+    if (fields.length !== 3) {
+      return {
+        error: `Expected three fields (source,target,value), found ${fields.length}.`,
+        line
+      };
+    }
+    const [source2, target, raw] = fields;
+    const value = Number.parseFloat(raw);
+    if (!Number.isFinite(value)) {
+      return { error: `"${raw}" is not a number.`, line };
+    }
+    add(source2);
+    add(target);
+    links.push({ source: source2, target, value });
+  }
+  if (!links.length) return { error: "No links: add lines like `A,B,10`." };
+  return { data: { nodes, links } };
+}
+function readRecords(lines) {
+  const records = [];
+  let i = 0;
+  while (i < lines.length) {
+    const start = lines[i];
+    if (start.text === "") {
+      i++;
+      continue;
+    }
+    const fields = [];
+    let text = start.text;
+    let pos = 0;
+    let field = "";
+    let quoted = false;
+    for (; ; ) {
+      if (quoted) {
+        const close = text.indexOf('"', pos);
+        if (close < 0) {
+          field += text.slice(pos);
+          i++;
+          if (i >= lines.length)
+            return { error: "A quoted field is never closed.", line: start.line };
+          field += "\n";
+          text = lines[i].text;
+          pos = 0;
+          continue;
+        }
+        field += text.slice(pos, close);
+        if (text[close + 1] === '"') {
+          field += '"';
+          pos = close + 2;
+          continue;
+        }
+        quoted = false;
+        pos = close + 1;
+        const rest = /^[ \t]*/.exec(text.slice(pos))[0].length;
+        pos += rest;
+        if (pos < text.length && text[pos] !== ",") {
+          return { error: "Unexpected text after a quoted field.", line: lines[i].line };
+        }
+        continue;
+      }
+      if (pos >= text.length) {
+        fields.push(field.trim());
+        break;
+      }
+      const ch = text[pos];
+      if (ch === ",") {
+        fields.push(field.trim());
+        field = "";
+        pos++;
+      } else if (ch === '"' && field.trim() === "") {
+        quoted = true;
+        field = "";
+        pos++;
+      } else if (ch === '"') {
+        return { error: "A quote inside an unquoted field.", line: lines[i].line };
+      } else {
+        field += ch;
+        pos++;
+      }
+    }
+    records.push({ fields, line: start.line });
+    i++;
+  }
+  return records;
+}
+
+// src/diagram/treemap/index.ts
+var NAME = String.raw`(?:"([^"]*)"|'([^']*)')`;
+var CLASS = String.raw`(?:\s*:::\s*([A-Za-z_]\w*))?`;
+var SECTION_RE = new RegExp(String.raw`^${NAME}${CLASS}$`);
+var LEAF_RE = new RegExp(String.raw`^${NAME}\s*[:,]\s*([0-9_.,]+)${CLASS}$`);
+function parseTreemap(source) {
+  const split = splitSource(source);
+  if (!/^\s*treemap(?:-beta)?\b/i.test(split.header)) {
+    return { error: "Not a treemap: the first line should be `treemap-beta`." };
+  }
+  const data = { items: [] };
+  const stack = [];
+  const firstLine = split.headerIndex + 2;
+  const lines = split.bodyLines;
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const line = firstLine + i;
+    const indent = /^[ \t]*/.exec(raw)[0].length;
+    const text = stripComment(raw).trim();
+    if (!text) continue;
+    const accBlock = /^accDescr\s*\{(.*)$/.exec(text);
+    if (accBlock) {
+      let body = accBlock[1];
+      while (!body.includes("}") && i + 1 < lines.length) body += `
+${lines[++i]}`;
+      if (!body.includes("}")) return { error: "`accDescr {` is never closed.", line };
+      data.accDescr = body.slice(0, body.indexOf("}")).trim();
+      continue;
+    }
+    const acc = /^(accTitle|accDescr)\s*:(.*)$/.exec(text);
+    if (acc) {
+      data[acc[1]] = acc[2].trim();
+      continue;
+    }
+    const title = /^title(?:[ \t]+(.*))?$/.exec(text);
+    if (title) {
+      data.title = (title[1] ?? "").trim() || void 0;
+      continue;
+    }
+    if (/^classDef\s/.test(text)) continue;
+    let item;
+    const leaf = LEAF_RE.exec(text);
+    const section = leaf ? null : SECTION_RE.exec(text);
+    if (leaf) {
+      const value = Number.parseFloat(leaf[3].replace(/,/g, ""));
+      if (!Number.isFinite(value)) return { error: `"${leaf[3]}" is not a number.`, line };
+      item = { name: leaf[1] ?? leaf[2], value };
+      if (leaf[4]) item.className = leaf[4];
+    } else if (section) {
+      item = { name: section[1] ?? section[2], children: [] };
+      if (section[3]) item.className = section[3];
+    } else {
+      return {
+        error: /^["']/.test(text) ? 'Expected `"Name"` for a section or `"Name": value` for a leaf.' : 'Names must be in quotes, e.g. `"Sales": 120`.',
+        line
+      };
+    }
+    while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
+    const parent = stack[stack.length - 1]?.item;
+    if (parent) parent.children.push(item);
+    else data.items.push(item);
+    if (item.children) stack.push({ item, indent });
+  }
+  if (!data.items.length) return { error: 'No items: add lines like `"Sales": 120`.' };
+  return { data };
+}
+function stripComment(line) {
+  let quote3 = null;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (quote3) {
+      if (ch === quote3) quote3 = null;
+    } else if (ch === '"' || ch === "'") {
+      quote3 = ch;
+    } else if (ch === "%" && line[i + 1] === "%") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function treemapValue(item) {
+  if (!item.children) return item.value ?? 0;
+  return item.children.reduce((sum, child) => sum + treemapValue(child), 0);
+}
+
 // src/diagram/controller.ts
-var EDITABLE_DIAGRAM_FAMILIES = ["flowchart", "state", "class", "er"];
+var EDITABLE_DIAGRAM_FAMILIES = [
+  "flowchart",
+  "state",
+  "class",
+  "er",
+  "pie",
+  "mindmap",
+  "quadrant",
+  "c4",
+  "architecture",
+  "sequence",
+  "gitGraph",
+  "gantt",
+  "timeline",
+  "journey",
+  "xychart",
+  "radar"
+];
 function diagramShapes(family) {
   if (family === "flowchart") return FLOWCHART_SHAPES.map((shape) => shape.name);
   if (family === "state") return STATE_SHAPES.map((shape) => shape.name);
-  return [];
+  if (family === "class" || family === "er") return [];
+  const shapes = familyUI(family)?.shapes ?? [];
+  return shapes.length > 1 ? shapes.map((shape) => shape.value) : [];
 }
 function diagramSupportsGroups(family) {
-  return family === "flowchart" || family === "state" || family === "class";
+  return familyUI(family)?.groups.supported ?? false;
 }
-var quote = (ids) => [...ids].map((id) => `"${id}"`).join(", ");
+function diagramSupportsDirection(family) {
+  return familyUI(family)?.directions !== false;
+}
+var quote2 = (ids) => [...ids].map((id) => `"${id}"`).join(", ");
 function validateDiagramEdit(doc, op) {
   const { graph, family } = doc;
   if (op.type === "replaceSource") return null;
@@ -133,15 +1342,15 @@ function validateDiagramEdit(doc, op) {
   const nodes = new Set(graph.nodes.map((n) => n.id));
   const groups = new Set(graph.groups.map((g) => g.id));
   const edges = new Set(graph.edges.map((e) => e.id));
-  const anyIds = () => nodes.size ? `existing node ids are ${quote([...nodes].slice(0, 20))}` : "the diagram has no nodes yet";
+  const anyIds = () => nodes.size ? `existing node ids are ${quote2([...nodes].slice(0, 20))}` : "the diagram has no nodes yet";
   const node = (id, allowGroup = false) => nodes.has(id) || allowGroup && groups.has(id) ? null : `There is no node "${id}"; ${anyIds()}.`;
-  const group = (id) => id === void 0 || groups.has(id) ? null : `There is no group "${id}"; ${groups.size ? `existing groups are ${quote(groups)}` : "the diagram has no groups"}.`;
-  const edge = (id) => edges.has(id) ? null : `There is no edge "${id}"; ${edges.size ? `existing edge ids are ${quote([...edges].slice(0, 20))}` : "the diagram has no edges yet"}.`;
+  const group = (id) => id === void 0 || groups.has(id) ? null : `There is no group "${id}"; ${groups.size ? `existing groups are ${quote2(groups)}` : "the diagram has no groups"}.`;
+  const edge = (id) => edges.has(id) ? null : `There is no edge "${id}"; ${edges.size ? `existing edge ids are ${quote2([...edges].slice(0, 20))}` : "the diagram has no edges yet"}.`;
   const shape = (name) => {
     if (name === void 0) return null;
     const shapes = diagramShapes(family);
     if (!shapes.length) return `Nodes of a ${family} diagram have no shapes to choose from.`;
-    return shapes.includes(name) ? null : `Unknown shape "${name}"; use one of ${quote(shapes)}.`;
+    return shapes.includes(name) ? null : `Unknown shape "${name}"; use one of ${quote2(shapes)}.`;
   };
   const free = (id) => !/^[A-Za-z0-9_][\w.-]*$/.test(id) ? `Id "${id}" is not a valid Mermaid id; use letters, digits, "_", "-" or ".".` : nodes.has(id) || groups.has(id) ? `Id "${id}" is already used; choose another.` : null;
   const first = (...problems) => problems.find((p) => p) ?? null;
@@ -183,7 +1392,8 @@ function validateDiagramEdit(doc, op) {
     case "setNodeParent":
       return first(...op.ids.map((id) => node(id, true)), group(op.parentId));
     case "setDirection":
-      return DIRECTIONS.includes(op.direction) ? null : `Unknown direction "${op.direction}"; use one of ${quote(DIRECTIONS)}.`;
+      if (!diagramSupportsDirection(family)) return `${family} diagrams have no direction.`;
+      return DIRECTIONS.includes(op.direction) ? null : `Unknown direction "${op.direction}"; use one of ${quote2(DIRECTIONS)}.`;
     default:
       return null;
   }
@@ -309,10 +1519,10 @@ var DiagramController = class {
    * document as it stands after the edits before it, and nothing changes when one fails.
    */
   apply(ops, label = "Edit diagram") {
-    const list = Array.isArray(ops) ? ops : [ops];
+    const list2 = Array.isArray(ops) ? ops : [ops];
     if (this.readOnly) return this.reject("The diagram is read-only.");
     let doc = this.doc;
-    for (const op of list) {
+    for (const op of list2) {
       const problem = validateDiagramEdit(doc, op);
       if (problem) return this.reject(problem);
       doc = applyEdits(doc, [op]);
@@ -382,6 +1592,7 @@ var ID = { type: "string", minLength: 1, description: 'A node id from get_diagra
 var IDS = (what) => ({ type: "array", items: { type: "string", minLength: 1 }, minItems: 1, description: what });
 var EDGE_ID = { type: "string", minLength: 1, description: 'An edge id from get_diagram (e.g. "L_A_B_0").' };
 var LABEL = (what) => ({ type: "string", description: what });
+var FIELD_VALUE = { type: ["string", "number", "boolean", "array", "null"] };
 var object = (properties, required = []) => ({
   type: "object",
   properties,
@@ -390,6 +1601,8 @@ var object = (properties, required = []) => ({
 });
 function describeDiagram(doc) {
   const { graph } = doc;
+  const ui = familyUI(doc.family);
+  const settings = pickFieldData(ui?.diagramFields, graph.data);
   return {
     family: doc.family,
     editable: doc.tier === "editable",
@@ -402,7 +1615,8 @@ function describeDiagram(doc) {
       ...n.parentId ? { parentId: n.parentId } : {},
       ...n.classes.length ? { classes: n.classes } : {},
       ...n.styles.length ? { styles: n.styles } : {},
-      ...n.data?.synthetic ? { synthetic: true } : {}
+      ...n.data?.synthetic ? { synthetic: true } : {},
+      ...ui?.nodeFields && Object.keys(pickFieldData(ui.nodeFields, n.data)).length ? { data: pickFieldData(ui.nodeFields, n.data) } : {}
     })),
     edges: graph.edges.map((e) => ({
       id: e.id,
@@ -410,7 +1624,8 @@ function describeDiagram(doc) {
       target: e.target,
       ...e.label ? { label: e.label } : {},
       pattern: e.pattern,
-      arrowEnd: e.arrowEnd
+      arrowEnd: e.arrowEnd,
+      ...ui?.edgeFields && Object.keys(pickFieldData(ui.edgeFields, e.data)).length ? { data: pickFieldData(ui.edgeFields, e.data) } : {}
     })),
     groups: graph.groups.map((g) => ({
       id: g.id,
@@ -419,6 +1634,14 @@ function describeDiagram(doc) {
       ...g.direction ? { direction: g.direction } : {}
     })),
     shapes: diagramShapes(doc.family),
+    ...Object.keys(settings).length ? { settings } : {},
+    ...ui && (ui.nodeFields?.length || ui.edgeFields?.length || ui.diagramFields?.length) ? {
+      fields: {
+        ...ui.nodeFields?.length ? { node: describeFields(ui.nodeFields) } : {},
+        ...ui.edgeFields?.length ? { edge: describeFields(ui.edgeFields) } : {},
+        ...ui.diagramFields?.length ? { diagram: describeFields(ui.diagramFields) } : {}
+      }
+    } : {},
     positions: Object.fromEntries(Object.entries(doc.meta.layout ?? {}).map(([id, [x, y]]) => [id, { x: Math.round(x), y: Math.round(y) }])),
     ...doc.diagnostics.length ? { diagnostics: doc.diagnostics.map((d) => ({ severity: d.severity, message: d.message, ...d.line ? { line: d.line } : {} })) } : {}
   };
@@ -456,7 +1679,7 @@ function createDiagramToolProvider(controller, options = {}) {
   const getDiagram = {
     name: "get_diagram",
     title: "Read the diagram",
-    description: "Returns the diagram: its Mermaid family (flowchart, state, class, er; other families are text only), direction, nodes (id, label, shape, parentId), edges (id, source, target, label), groups (subgraphs / composite states), the shapes nodes can take, stored canvas positions, any parse diagnostics and the selection. Use the ids it returns with the write tools.",
+    description: 'Returns the diagram: its Mermaid family (flowchart, state, class, er, pie, mindmap, quadrant, c4, architecture, sequence, gitGraph, gantt, timeline, journey, xychart, radar; sankey, block, packet, kanban and treemap are text only), direction, title, nodes (id, label, shape, parentId, data), edges (id, source, target, label, data), groups (subgraphs, composite states, sections, boxes\u2026), the shapes nodes can take, diagram settings, the data fields each family offers ("fields": node, edge and diagram field keys with their types), stored canvas positions, any parse diagnostics and the selection. Use the ids and field keys it returns with the write tools.',
     inputSchema: object({ includeSource: { type: "boolean", description: "Also return the Mermaid text (default false)." } }),
     annotations: { title: "Read the diagram", ...READ },
     handler: async ({ includeSource = false }) => {
@@ -491,7 +1714,7 @@ function createDiagramToolProvider(controller, options = {}) {
   const loadMermaid = {
     name: "load_diagram_mermaid",
     title: "Replace the diagram with Mermaid",
-    description: "Replaces the whole diagram with Mermaid text (one undo step). Flowchart, state, class and ER diagrams become editable on the canvas; other families are kept as text. Returns the family, node and edge counts and any parse diagnostics. Prefer the per-operation tools for small changes: they keep the rest of the text as written.",
+    description: "Replaces the whole diagram with Mermaid text (one undo step). Flowchart, state, class, ER, pie, mindmap, quadrant, C4, architecture, sequence, gitGraph, Gantt, timeline, journey, XY and radar diagrams become editable; sankey, block, packet, kanban and treemap are kept as text. Returns the family, node and edge counts and any parse diagnostics. Prefer the per-operation tools for small changes: they keep the rest of the text as written.",
     inputSchema: object({ source: { type: "string", minLength: 1, description: 'Mermaid text, starting with a header such as "flowchart LR".' } }, ["source"]),
     annotations: { title: "Replace the diagram with Mermaid", ...DESTRUCTIVE },
     handler: async ({ source }) => {
@@ -520,8 +1743,9 @@ function createDiagramToolProvider(controller, options = {}) {
     inputSchema: object(
       {
         label: LABEL("Text shown in the node."),
-        id: { type: "string", pattern: "^[A-Za-z0-9_][\\w.-]*$", description: 'Mermaid id (default: the next free "N<number>").' },
-        shape: { type: "string", description: 'One of the shapes get_diagram lists (default "rect"). Flowchart and state diagrams only.' },
+        id: { type: "string", pattern: "^[A-Za-z0-9_][\\w.-]*$", description: 'Mermaid id (default: the next free id for the family, e.g. "n3", "slice4", "task2").' },
+        shape: { type: "string", description: `One of the shapes get_diagram lists (default: the family's usual node, e.g. "rect").` },
+        data: { type: "object", additionalProperties: FIELD_VALUE, description: `Values for the family's node fields (get_diagram "fields.node"), e.g. {"value": 40} for a pie slice. Defaults fill in the rest.` },
         parentId: { type: "string", description: "Group (subgraph) to add the node to." },
         from: { type: "string", description: "An existing node to connect to the new node." },
         edgeLabel: LABEL('Label of the edge from "from" (needs "from").'),
@@ -531,14 +1755,22 @@ function createDiagramToolProvider(controller, options = {}) {
       ["label"]
     ),
     annotations: { title: "Add a node", ...WRITE },
-    handler: async ({ label, id, shape, parentId, from, edgeLabel, x, y }) => {
+    handler: async ({ label, id, shape, parentId, from, edgeLabel, x, y, data }) => {
       requireEditable();
       if (x === void 0 !== (y === void 0)) throw new Error("Give both x and y, or neither to place the node automatically.");
       if (edgeLabel !== void 0 && from === void 0) throw new Error('edgeLabel needs "from", the node the edge starts at.');
-      const nodeId = id ?? controller.nextId();
+      const ui = familyUI(doc().family);
+      const nodeId = id ?? (ui && !["flowchart", "state", "class", "er"].includes(ui.family) ? ui.nextId(doc().graph) : controller.nextId());
+      const defaults = ui?.newNode?.(doc().graph, parentId) ?? {};
+      const nodeShape = shape ?? defaults.shape;
+      const nodeData = { ...defaults.data ?? {}, ...data ? checkFieldData(ui?.nodeFields, data, `a ${doc().family} node`, nodeShape) : {} };
       const before = edgeIds();
       const ops = [
-        { type: "addNode", node: { id: nodeId, label, ...shape ? { shape } : {}, ...parentId ? { parentId } : {} }, ...x !== void 0 ? { position: [x, y] } : {} }
+        {
+          type: "addNode",
+          node: { ...defaults, id: nodeId, label, ...nodeShape ? { shape: nodeShape } : {}, ...parentId ? { parentId } : {}, ...Object.keys(nodeData).length ? { data: nodeData } : {} },
+          ...x !== void 0 ? { position: [x, y] } : {}
+        }
       ];
       if (from !== void 0) ops.push({ type: "addEdge", edge: { source: from, target: nodeId, ...edgeLabel ? { label: edgeLabel } : {} } });
       const d = await apply(ops, "Add node");
@@ -713,9 +1945,9 @@ function createDiagramToolProvider(controller, options = {}) {
     ),
     annotations: { title: "Move nodes", ...WRITE_IDEMPOTENT },
     handler: async ({ moves }) => {
-      const list = moves;
+      const list2 = moves;
       requireEditable();
-      await apply({ type: "moveNodes", moves: pinned(list.map((m) => ({ id: m.id, position: [m.x, m.y] }))) }, "Move");
+      await apply({ type: "moveNodes", moves: pinned(list2.map((m) => ({ id: m.id, position: [m.x, m.y] }))) }, "Move");
       return { moved: moves };
     }
   };
@@ -743,6 +1975,81 @@ function createDiagramToolProvider(controller, options = {}) {
       return { redone, ...redone ? { label } : {} };
     }
   };
+  const fieldsOf = (kind2) => {
+    const ui = familyUI(doc().family);
+    return kind2 === "node" ? ui?.nodeFields : kind2 === "edge" ? ui?.edgeFields : ui?.diagramFields;
+  };
+  const setNodeData = {
+    name: "set_diagram_node_data",
+    title: "Set a node's data fields",
+    description: `Sets values of a node's data fields: a pie slice's value, a Gantt task's start and end, a quadrant point's x and y, a journey task's score, an XY series' values, a C4 element's technology\u2026 Field keys and types are listed in get_diagram "fields.node"; null clears a field. Returns the node with its data.`,
+    inputSchema: object(
+      {
+        id: ID,
+        data: { type: "object", additionalProperties: FIELD_VALUE, description: 'Field key \u2192 value, e.g. {"value": 40} or {"x": 0.3, "y": 0.8}. null clears the field.' }
+      },
+      ["id", "data"]
+    ),
+    annotations: { title: "Set a node's data fields", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, data }) => {
+      requireEditable();
+      const node = doc().graph.nodes.find((n) => n.id === id);
+      if (!node) throw new Error(`There is no node "${id}"; call get_diagram for the node ids.`);
+      const patch = checkFieldData(fieldsOf("node"), data, `a ${doc().family} node`, node.shape);
+      const d = await apply({ type: "setNodeData", id, data: patch }, "Edit data");
+      const after = d.graph.nodes.find((n) => n.id === id);
+      return { node: { ...nodeOut(d, id), data: pickFieldData(fieldsOf("node"), after?.data) } };
+    }
+  };
+  const setEdgeData = {
+    name: "set_diagram_edge_data",
+    title: "Set an edge's data fields",
+    description: `Sets values of an edge's data fields: a sequence message's activation, a C4 relation's technology, an architecture edge's sides\u2026 Field keys and types are listed in get_diagram "fields.edge"; null clears a field. Returns the edge with its data.`,
+    inputSchema: object(
+      {
+        id: EDGE_ID,
+        data: { type: "object", additionalProperties: FIELD_VALUE, description: "Field key \u2192 value. null clears the field." }
+      },
+      ["id", "data"]
+    ),
+    annotations: { title: "Set an edge's data fields", ...WRITE_IDEMPOTENT },
+    handler: async ({ id, data }) => {
+      requireEditable();
+      if (!doc().graph.edges.some((e) => e.id === id)) throw new Error(`There is no edge "${id}"; call get_diagram for the edge ids.`);
+      const patch = checkFieldData(fieldsOf("edge"), data, `a ${doc().family} edge`);
+      const d = await apply({ type: "setEdgeData", id, data: patch }, "Edit data");
+      const edge = d.graph.edges.find((e) => e.id === id);
+      return { edge: { id, ...edge ? { source: edge.source, target: edge.target } : {}, data: pickFieldData(fieldsOf("edge"), edge?.data) } };
+    }
+  };
+  const setSettings = {
+    name: "set_diagram_settings",
+    title: "Change diagram settings",
+    description: `Sets diagram-level fields: a pie chart's showData, a Gantt chart's dateFormat and excludes, a quadrant chart's axis labels, an XY chart's categories and axis range, sequence autonumbering\u2026 Field keys and types are listed in get_diagram "fields.diagram"; null clears a field. Returns all settings.`,
+    inputSchema: object(
+      { data: { type: "object", additionalProperties: FIELD_VALUE, description: "Field key \u2192 value. null clears the field." } },
+      ["data"]
+    ),
+    annotations: { title: "Change diagram settings", ...WRITE_IDEMPOTENT },
+    handler: async ({ data }) => {
+      requireEditable();
+      const patch = checkFieldData(fieldsOf("diagram"), data, `a ${doc().family} diagram`);
+      const d = await apply({ type: "setGraphData", data: patch }, "Edit settings");
+      return { settings: pickFieldData(fieldsOf("diagram"), d.graph.data) };
+    }
+  };
+  const setTitle = {
+    name: "set_diagram_title",
+    title: "Set the diagram title",
+    description: "Sets the title shown above the diagram (a title statement, or frontmatter for families without one), or removes it with null. Returns the title.",
+    inputSchema: object({ title: { type: ["string", "null"], description: "The new title, or null to remove it." } }, ["title"]),
+    annotations: { title: "Set the diagram title", ...WRITE_IDEMPOTENT },
+    handler: async ({ title }) => {
+      requireEditable();
+      const d = await apply({ type: "setTitle", title: title === null || title === "" ? void 0 : title }, "Set title");
+      return { title: d.graph.title ?? null };
+    }
+  };
   const renderDiagram = {
     name: "render_diagram",
     title: "Render the diagram",
@@ -765,7 +2072,7 @@ function createDiagramToolProvider(controller, options = {}) {
     }
   };
   const reads = [getDiagram, exportMermaid, findDiagrams, ...options.renderSvg ? [renderDiagram] : []];
-  const writes = [loadMermaid, addNode, removeElements, renameNode, setShape, setStyle, connect, removeEdges, labelEdge, reconnect, setDirection, group, ungroup, move, undo, redo];
+  const writes = [loadMermaid, addNode, removeElements, renameNode, setShape, setStyle, setNodeData, connect, removeEdges, labelEdge, setEdgeData, reconnect, setDirection, setTitle, setSettings, group, ungroup, move, undo, redo];
   return {
     id: options.id ?? "diagram",
     namespace: options.namespace,
@@ -1103,6 +2410,8 @@ function planDiagramEdits(source, place, ops, speed = 1) {
   });
 }
 export {
+  ARCH_METRICS,
+  C4_METRICS,
   CLASS_RELATIONS,
   DIRECTIONS,
   DiagramController,
@@ -1110,58 +2419,159 @@ export {
   EDITABLE_DIAGRAM_FAMILIES,
   ER_CARDINALITIES,
   ER_PATTERNS,
+  FAMILY_BLANKS,
+  FAMILY_DESCRIPTIONS,
+  FAMILY_TEMPLATES,
+  FAMILY_TITLES,
   FLOWCHART_SHAPES,
+  GANTT_CONFIG_KEYS,
+  GANTT_METRICS,
+  GANTT_TAGS,
   META_COMMENT_PREFIX,
   META_FRONTMATTER_KEY,
+  POINT_BOX,
   PRESENCE_COLORS,
   PerformanceQueue,
   PresenceStore,
+  QUADRANT_METRICS,
+  RADAR_CHART_BOX,
+  SEQUENCE_METRICS,
   STATE_SHAPES,
+  XY_CHART_BOX,
+  afterIds,
   applyEdit,
   applyEdits,
+  applyStatementEdit,
+  architectureAdapter,
+  architectureArrow,
+  architectureEdgeRoute,
+  architectureGrammar,
+  architectureLayout,
+  architectureUI,
+  c4Adapter,
+  c4ArrowHead,
+  c4BoundaryText,
+  c4ElementGeometry,
+  c4ElementType,
+  c4Grammar,
+  c4Layout,
+  c4RelGeometry,
+  c4Stereotype,
+  c4UI,
   canonicalShape,
   changedItems,
+  checkFieldData,
   classGrammar,
+  classUI,
   createDiagramToolProvider,
   createInstantPresenceClock,
   createLineAdapter,
   createPassthroughAdapter,
+  createStatementAdapter,
   describeDiagram,
+  describeFields,
   detectFamily,
   detectFamilyFromHeader,
   diagramShapes,
+  diagramSupportsDirection,
   diagramSupportsGroups,
   draftFrames,
+  dropMetaKeys,
   emptyMeta,
   erGrammar,
+  erUI,
+  familyUI,
+  filterInPlace,
   findMermaidSources,
   flowchartAdapter,
+  flowchartUI,
+  formatAxis,
   formatChain,
+  formatGanttDate,
   formatLink,
   formatNode,
+  ganttAdapter,
+  ganttGeometry,
+  ganttGrammar,
+  ganttUI,
   getDiagramAdapter,
+  getFamilyLayout,
+  gitGraphAdapter,
+  gitGraphGrammar,
+  gitGraphUI,
+  indentOf,
   isMetaEmpty,
+  journeyAdapter,
+  journeyGrammar,
+  journeyLayout,
+  journeyUI,
   mergeMeta,
+  mindmapAdapter,
+  mindmapGrammar,
+  mindmapUI,
   parseAttributes,
   parseChain,
   parseFlowchartSource,
+  parseGanttDate,
   parseLink,
   parseMembers,
   parseMermaid,
+  parseSankey,
   parseStatement,
+  parseStatementDocument,
+  parseTreemap,
+  pickFieldData,
+  pieAdapter,
+  pieGrammar,
+  pieUI,
   planDiagramEdit,
   planDiagramEdits,
+  pointCentre,
+  pointPosition,
+  positionToData,
+  quadrantAdapter,
+  quadrantGeometry,
+  quadrantGrammar,
+  quadrantSpace,
+  quadrantUI,
+  quote,
   quoteLabelIfNeeded,
+  radarAdapter,
+  radarGrammar,
+  radarUI,
   realPresenceClock,
   registerDiagramAdapter,
+  registerFamilyLayout,
   relationFor,
+  renameMetaKey,
   resolveShape,
+  sequenceAdapter,
+  sequenceGeometry,
+  sequenceGrammar,
+  sequenceUI,
   serializeMermaid,
   serializeMeta,
+  serializeStatementDocument,
+  serviceLabelLines,
+  sharedFrameLayout,
+  slugId,
+  spaceInput,
+  splitOutsideQuotes,
   splitSource,
   splitStatements,
   stateGrammar,
+  stateUI,
   supportTierOf,
-  validateDiagramEdit
+  timelineAdapter,
+  timelineGrammar,
+  timelineLayout,
+  timelineUI,
+  treemapValue,
+  uniqueId,
+  unquote,
+  validateDiagramEdit,
+  xyChartAdapter,
+  xyChartGrammar,
+  xyChartUI
 };
 //# sourceMappingURL=index.js.map