agentic-mermaid 0.1.1 → 0.1.2

package/dist/chunk-4QECACIA.js

@@ -0,0 +1,4702 @@
+import {
+  BRAND_CONSTRAINT_DESCRIPTORS,
+  BRAND_CONSTRAINT_WARNING_POLICY,
+  DEFAULT_LABEL_CHAR_CAP,
+  FAMILY_CAPABILITY_COLUMNS,
+  FAMILY_CONFORMANCE_VERSION,
+  FONT_SIZES,
+  FONT_WEIGHTS,
+  FamilyLayoutError,
+  GANTT_TODAY_MARKER_STYLE_PROPS,
+  MAX_RADAR_TICKS,
+  MIX,
+  MermaidFamilyDetectionError,
+  ParsedDiagramFamilyMismatchError,
+  RESOLVED_TERMINAL_COLOR_MODES,
+  WARNING_SEVERITY,
+  accessibilityFromBody,
+  applyGanttFrontmatterConfig,
+  assertFamilyScopedRenderOptionDeclaration,
+  auditRouteContracts,
+  builtinFamilyMetadata,
+  classifyRoutes,
+  compareCodePointStrings,
+  convertToAsciiGraph,
+  createMapping,
+  emitResolvedConfigDiagnostics,
+  emptyRenderedLayout,
+  ensureAccessibilityLines,
+  erUnsupportedSyntaxWarnings,
+  err,
+  executeGraphicalRequest,
+  expandInlineNamespaceStatement,
+  extractLabelsGeneric,
+  familyConfigDiagnostics,
+  familyDetectionDiagnosticFromPreservedBody,
+  findRouteHitches,
+  flowchartUnsupportedSyntaxWarnings,
+  flowchartV11ShapeNames,
+  formatGanttInstant,
+  ganttGeometryWarnings,
+  ganttScheduleWarning,
+  geometryBounds,
+  getFamily,
+  graphemes,
+  isSafeActionHref,
+  labelOverflowWarning,
+  layoutGeometryWarnings,
+  layoutResolvedFamilyToRendered,
+  lowerPositionedFamilyScene,
+  measureMultilineText,
+  normalizeBrTags,
+  normalizeMermaidSource,
+  normalizeV11Shape,
+  ok,
+  parseActorLinks,
+  parseClassDeclaration,
+  parseClassDiagram,
+  parseClassInteraction,
+  parseClassReference,
+  parseGanttModel,
+  parseMermaid,
+  parseRegisteredMermaid,
+  parseTodayMarkerStyle,
+  plainTextFromInlineFormatting,
+  positionFamilyArtifact,
+  positionResolvedFamily,
+  prepareRenderInput,
+  receiptOf,
+  renderContractDigest,
+  renderMermaidASCII,
+  renderMermaidASCIIWithReceipt,
+  renderMermaidSVG,
+  renderMermaidSVGWithReceipt,
+  renderPortablePngGraphicalProjection,
+  renderPositionedMermaidSVG,
+  resolveGanttSchedule,
+  resolveRenderRequestForExecution,
+  sameExtensionIdentity,
+  sanitizeTerminalText,
+  sceneNodePrimitives,
+  sequenceMessageContexts,
+  sequenceMessages,
+  serializeMermaid,
+  splitFlowchartStatements,
+  stageFamilyCandidateForConformance,
+  stateBodyToGraph,
+  toFinite,
+  toHex,
+  toMermaidLines,
+  tryParseCssColor,
+  unknownOpMessage,
+  visualWidth,
+  wcagCssContrastRatio,
+  wrapperPrefix
+} from "./chunk-ZYMMKQ3I.js";
+
+// src/agent/trace-log.ts
+var appendFn;
+function resolveAppend() {
+  if (appendFn !== void 0) return appendFn;
+  appendFn = null;
+  try {
+    const proc = globalThis.process;
+    const fs = proc?.getBuiltinModule?.("node:fs");
+    if (typeof fs?.appendFileSync === "function") appendFn = fs.appendFileSync;
+  } catch {
+  }
+  return appendFn;
+}
+function logToolInvocation(verb, ok2) {
+  const path = globalThis.process?.env?.AM_TRACE_LOG;
+  if (!path) return;
+  const record = ok2 === void 0 ? { verb } : { verb, ok: ok2 };
+  try {
+    resolveAppend()?.(path, JSON.stringify(record) + "\n");
+  } catch {
+  }
+}
+
+// src/agent/op-schema.ts
+var NODE_SHAPES = [
+  "rectangle",
+  "service",
+  "rounded",
+  "diamond",
+  "stadium",
+  "circle",
+  "subroutine",
+  "doublecircle",
+  "hexagon",
+  "cylinder",
+  "asymmetric",
+  "trapezoid",
+  "trapezoid-alt",
+  "lean-r",
+  "lean-l",
+  "state-start",
+  "state-end"
+];
+var EDGE_STYLES = ["solid", "dotted", "thick", "invisible"];
+var SEQUENCE_MESSAGE_STYLES = ["sync", "reply", "async", "async-dashed", "lost", "lost-dashed"];
+var PARTICIPANT_KINDS = ["participant", "actor"];
+var SEQUENCE_FRAGMENT_KINDS = ["alt", "opt", "loop", "par"];
+var CLASS_REL_KINDS = ["inheritance", "composition", "aggregation", "association", "dependency", "realization", "link-solid", "link-dashed"];
+var ER_CARDINALITIES = ["one-only", "zero-or-one", "zero-or-many", "one-or-many"];
+var ARCH_SIDES = ["L", "R", "T", "B"];
+var ARCH_BOUNDARIES = ["item", "group"];
+var SERIES_KINDS = ["bar", "line"];
+var AXIS_KINDS = ["x", "y"];
+var GANTT_STATUSES = ["active", "done", "crit"];
+var MINDMAP_SHAPES = ["default", "rect", "rounded", "circle", "cloud", "bang", "hexagon"];
+var GIT_COMMIT_TYPES = ["NORMAL", "REVERSE", "HIGHLIGHT"];
+var GRATICULE_KINDS = ["circle", "polygon"];
+var str = (required = true) => ({ type: "string", required });
+var num = (required = true) => ({ type: "number", required });
+var bool = (required = true) => ({ type: "boolean", required });
+var numOrNull = (required = true) => ({ type: "number-or-null", required });
+var boolOrNull = (required = true) => ({ type: "boolean-or-null", required });
+var strOrNull = (required = true) => ({ type: "string-or-null", required });
+var strArr = (required = true) => ({ type: "string-array", required });
+var numArr = (required = true) => ({ type: "number-array", required });
+var objOrNull = (required = true) => ({ type: "object-or-null", required });
+var oneOf = (values, required = true, nullable = false) => ({ type: "enum", values, nullable, required });
+var withNote = (spec, note) => ({ ...spec, note });
+var FLOWCHART_SHAPE_VALUES = [
+  ...NODE_SHAPES,
+  ...flowchartV11ShapeNames().filter((name) => !NODE_SHAPES.includes(name))
+];
+var FLOWCHART_DIRECTIONS = ["TD", "TB", "LR", "BT", "RL"];
+var FLOWCHART_SCHEMA = {
+  add_node: { fields: { id: str(), label: str(), shape: withNote(oneOf(FLOWCHART_SHAPE_VALUES, false), "default: rectangle; also accepts Mermaid v11 @{ shape } names/aliases (e.g. manual-input)"), parent: str(false) } },
+  remove_node: { fields: { id: str() } },
+  rename_node: { fields: { from: str(), to: str() } },
+  set_label: { fields: { target: withNote(str(), 'a node id, an authored edge ID (e1), or "from->to"/"from->to#k"'), label: str() } },
+  add_edge: { fields: { from: str(), to: str(), label: str(false), style: withNote(oneOf(EDGE_STYLES, false), "default: solid") } },
+  remove_edge: { fields: { id: withNote(str(), 'an authored edge ID (e1), or "from->to"/"from->to#k" for the k-th parallel edge') } },
+  set_shape: { fields: { id: str(), shape: withNote(oneOf(FLOWCHART_SHAPE_VALUES), "a geometry name or a Mermaid v11 @{ shape } name/alias; v11 names render with the documented geometry mapping and serialize with the authored spelling") } },
+  set_direction: { fields: { direction: oneOf(FLOWCHART_DIRECTIONS), subgraph: withNote(str(false), "omit to set the diagram direction; a subgraph id sets that subgraph's direction override") } },
+  add_subgraph: { fields: { id: str(), label: str(false), parent: withNote(str(false), "nest inside this subgraph"), members: withNote(strArr(false), "existing node ids MOVED into the new subgraph") } },
+  remove_subgraph: { fields: { id: str(), removeMembers: withNote(bool(false), "default false: dissolve \u2014 members move to the parent scope; true also removes member nodes and their edges") } },
+  move_node: { fields: { id: str(), subgraph: withNote(strOrNull(), "target subgraph id; null moves the node to the top level") } },
+  define_class: { fields: { name: str(), style: withNote(str(), 'CSS-like pairs, e.g. "fill:#f96,stroke:#333,stroke-width:2px"') } },
+  set_node_class: { fields: { id: str(), className: withNote(strOrNull(), "assigns a classDef name (define_class or source classDef); null removes the assignment") } },
+  set_node_style: { fields: { id: str(), style: withNote(strOrNull(), 'inline style pairs, e.g. "fill:#bbf"; null clears') } }
+};
+var STATE_DIRECTIONS = ["TD", "TB", "LR", "BT", "RL"];
+var STATE_NOTE_SIDES = ["left", "right"];
+var STATE_SCHEMA = {
+  add_state: { fields: { id: str(), label: strOrNull(false), parent: strOrNull(false), region: num(false) } },
+  remove_state: { fields: { id: str(), recursive: withNote(bool(false), "default false: refuse a non-empty composite; true removes the whole subtree (transitions + notes cascade)") } },
+  rename_state: { fields: { from: str(), to: str() } },
+  set_state_label: { fields: { id: str(), label: strOrNull() } },
+  add_transition: { fields: { from: withNote(str(), 'a state id, "[*]", or a history ref like "X[H]"'), to: withNote(str(), 'a state id, "[*]", or a history ref like "X[H]"'), label: strOrNull(false), parent: strOrNull(false), region: num(false) } },
+  remove_transition: { fields: { index: num(false), from: str(false), to: str(false), parent: strOrNull(false), region: num(false) }, requireOneOf: ["index", "from", "to"] },
+  set_transition_label: { fields: { index: num(false), from: str(false), to: str(false), label: strOrNull(), parent: strOrNull(false), region: num(false) }, requireOneOf: ["index", "from", "to"] },
+  make_composite: { fields: { id: str(), members: strArr(), label: strOrNull(false) } },
+  set_direction: { fields: { direction: oneOf(STATE_DIRECTIONS), state: withNote(strOrNull(false), "omit to set the diagram direction; a composite id sets that composite's direction override") } },
+  move_state: { fields: { id: str(), parent: withNote(strOrNull(), "target composite id; null moves the state to the top level"), region: num(false) } },
+  dissolve_composite: { fields: { id: withNote(str(), "children and inner transitions hoist into the parent scope; rejects while transitions/notes still reference the composite") } },
+  add_note: { fields: { target: str(), side: withNote(oneOf(STATE_NOTE_SIDES, false), "default: right"), text: withNote(str(), "multi-line text serializes as a block note") } },
+  remove_note: { fields: { index: num() } },
+  set_note_text: { fields: { index: num(), text: str() } },
+  define_class: { fields: { name: str(), style: withNote(str(), 'CSS-like pairs, e.g. "fill:#f96,stroke:#333"') } },
+  set_state_class: { fields: { id: str(), className: strOrNull() } },
+  set_state_style: { fields: { id: str(), style: withNote(strOrNull(), "inline style pairs; null clears") } },
+  set_transition_style: { fields: { index: num(false), default: bool(false), style: strOrNull(), parent: strOrNull(false), region: num(false) }, requireOneOf: ["index", "default"] }
+};
+var SEQUENCE_SCHEMA = {
+  add_participant: { fields: { id: str(), label: str(false), participantKind: oneOf(PARTICIPANT_KINDS, false) } },
+  remove_participant: { fields: { id: str() } },
+  add_message: { fields: { from: str(), to: str(), text: str(), style: withNote(oneOf(SEQUENCE_MESSAGE_STYLES, false), "default: sync"), index: withNote(num(false), "top-level insert position; default: append") } },
+  remove_message: { fields: { index: num() } },
+  set_message_text: { fields: { index: num(), text: str() } },
+  move_message: { fields: { from: withNote(num(), "top-level message index"), to: withNote(num(), "top-level target position") } },
+  set_participant_label: { fields: { id: str(), label: str() } },
+  add_fragment: { fields: { fragmentKind: oneOf(SEQUENCE_FRAGMENT_KINDS), label: str(false), index: withNote(num(false), "fragment insert position; default: append") } },
+  remove_fragment: { fields: { index: num() } },
+  set_fragment_label: { fields: { index: num(), label: strOrNull() } },
+  add_fragment_branch: { fields: { fragmentIndex: num(), label: str(false) } },
+  set_fragment_branch_label: { fields: { fragmentIndex: num(), branchIndex: num(), label: strOrNull() } },
+  add_fragment_message: { fields: { fragmentIndex: num(), branchIndex: withNote(num(false), "default: 0"), from: str(), to: str(), text: str(), style: withNote(oneOf(SEQUENCE_MESSAGE_STYLES, false), "default: sync"), index: withNote(num(false), "message insert position; default: append") } },
+  remove_fragment_message: { fields: { fragmentIndex: num(), branchIndex: withNote(num(false), "default: 0"), index: num() } },
+  set_fragment_message_text: { fields: { fragmentIndex: num(), branchIndex: withNote(num(false), "default: 0"), index: num(), text: str() } }
+};
+var TIMELINE_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  add_section: { fields: { label: str(), index: withNote(num(false), "insert position; omit to append") } },
+  remove_section: { fields: { index: num() } },
+  set_section_label: { fields: { index: num(), label: str() } },
+  add_period: { fields: { sectionIndex: num(), label: str(), events: strArr(false), index: withNote(num(false), "insert position; omit to append") } },
+  remove_period: { fields: { sectionIndex: num(), periodIndex: num() } },
+  set_period_label: { fields: { sectionIndex: num(), periodIndex: num(), label: str() } },
+  add_event: { fields: { sectionIndex: num(), periodIndex: num(), text: str(), index: withNote(num(false), "insert position; omit to append") } },
+  remove_event: { fields: { sectionIndex: num(), periodIndex: num(), eventIndex: num() } },
+  set_event_text: { fields: { sectionIndex: num(), periodIndex: num(), eventIndex: num(), text: str() } },
+  move_period: { fields: { fromSection: num(), fromIndex: num(), toSection: num(), toIndex: withNote(num(), "insert position in the target section, applied after removal") } },
+  move_event: { fields: { fromSection: num(), fromPeriod: num(), fromIndex: num(), toSection: num(), toPeriod: num(), toIndex: withNote(num(), "insert position in the target period, applied after removal") } },
+  move_section: { fields: { from: num(), to: num() } },
+  set_accessibility_title: { fields: { title: strOrNull() } },
+  set_accessibility_description: { fields: { description: strOrNull() } }
+};
+var CLASS_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  add_class: { fields: { id: str(), label: str(false), generic: withNote(str(false), "Mermaid generic parameter text without surrounding ~ delimiters"), members: strArr(false), namespace: withNote(str(false), 'dot path, e.g. "Platform.Auth"; declared on demand') } },
+  remove_class: { fields: { id: str() } },
+  rename_class: { fields: { from: str(), to: str() } },
+  set_class_generic: { fields: { class: str(), generic: withNote(strOrNull(), "parameter text without ~ delimiters; null removes it") } },
+  add_member: { fields: { class: str(), text: str() } },
+  remove_member: { fields: { class: str(), index: num() } },
+  add_relation: { fields: { from: str(), to: str(), relKind: oneOf(CLASS_REL_KINDS), label: str(false) } },
+  remove_relation: { fields: { index: num() } },
+  add_note: { fields: { text: str(), for: str(false) } },
+  remove_note: { fields: { index: num() } },
+  set_class_namespace: { fields: { class: str(), namespace: withNote(strOrNull(), "dot path moves the class into that namespace (declared on demand); null moves it to the top level") } },
+  define_class: { fields: { name: str(), style: withNote(str(), 'CSS-like pairs, e.g. "fill:#f96,stroke:#333"') } },
+  set_css_class: { fields: { class: str(), className: strOrNull() } },
+  set_class_style: { fields: { class: str(), style: strOrNull() } }
+};
+var ER_SCHEMA = {
+  add_entity: { fields: { id: str(), label: str(false), attributes: strArr(false) } },
+  remove_entity: { fields: { id: str() } },
+  rename_entity: { fields: { from: str(), to: str() } },
+  set_entity_label: { fields: { entity: str(), label: strOrNull() } },
+  add_attribute: { fields: { entity: str(), text: str() } },
+  remove_attribute: { fields: { entity: str(), index: num() } },
+  add_relation: { fields: { from: str(), to: str(), leftCard: oneOf(ER_CARDINALITIES), rightCard: oneOf(ER_CARDINALITIES), dashed: bool(false), label: str(false) } },
+  remove_relation: { fields: { index: num() } },
+  set_direction: { fields: { direction: oneOf(STATE_DIRECTIONS) } },
+  define_class: { fields: { name: str(), style: str() } },
+  set_entity_class: { fields: { entity: str(), className: strOrNull() } },
+  set_entity_style: { fields: { entity: str(), style: strOrNull() } }
+};
+var JOURNEY_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  add_section: { fields: { label: str(), index: withNote(num(false), "insert position; omit to append") } },
+  remove_section: { fields: { index: num() } },
+  set_section_label: { fields: { index: num(), label: str() } },
+  add_task: { fields: { sectionIndex: num(), text: str(), score: withNote(num(), "integer 1..5"), actors: strArr(false), index: withNote(num(false), "insert position; omit to append") } },
+  remove_task: { fields: { sectionIndex: num(), taskIndex: num() } },
+  set_task_text: { fields: { sectionIndex: num(), taskIndex: num(), text: str() } },
+  set_task_score: { fields: { sectionIndex: num(), taskIndex: num(), score: withNote(num(), "integer 1..5") } },
+  set_task_actors: { fields: { sectionIndex: num(), taskIndex: num(), actors: strArr() } },
+  rename_actor: { fields: { from: str(), to: str() } },
+  move_task: { fields: { fromSection: num(), fromIndex: num(), toSection: num(), toIndex: withNote(num(), "insert position in the target section, applied after removal") } },
+  move_section: { fields: { from: num(), to: num() } },
+  set_accessibility_title: { fields: { title: strOrNull() } },
+  set_accessibility_description: { fields: { description: strOrNull() } }
+};
+var ARCHITECTURE_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  set_accessibility_title: { fields: { title: strOrNull() } },
+  set_accessibility_description: { fields: { description: strOrNull() } },
+  add_service: { fields: { id: str(), label: str(false), icon: strOrNull(false), group: strOrNull(false) } },
+  remove_service: { fields: { id: str() } },
+  rename_service: { fields: { from: str(), to: str() } },
+  set_service_label: { fields: { id: str(), label: str() } },
+  set_service_icon: { fields: { id: str(), icon: strOrNull() } },
+  move_service: { fields: { id: str(), group: strOrNull() } },
+  add_junction: { fields: { id: str(), group: strOrNull(false) } },
+  remove_junction: { fields: { id: str() } },
+  rename_junction: { fields: { from: str(), to: str() } },
+  move_junction: { fields: { id: str(), group: strOrNull() } },
+  add_group: { fields: { id: str(), label: str(false), icon: strOrNull(false), parent: strOrNull(false) } },
+  set_group_label: { fields: { id: str(), label: str() } },
+  remove_group: { fields: { id: str() } },
+  add_edge: { fields: { from: str(), to: str(), fromSide: oneOf(ARCH_SIDES), toSide: oneOf(ARCH_SIDES), fromBoundary: oneOf(ARCH_BOUNDARIES, false), toBoundary: oneOf(ARCH_BOUNDARIES, false), label: strOrNull(false), hasArrowStart: bool(false), hasArrowEnd: bool(false) } },
+  update_edge: { fields: { index: num(), from: str(false), to: str(false), fromSide: oneOf(ARCH_SIDES, false), toSide: oneOf(ARCH_SIDES, false), fromBoundary: oneOf(ARCH_BOUNDARIES, false), toBoundary: oneOf(ARCH_BOUNDARIES, false), label: strOrNull(false), hasArrowStart: bool(false), hasArrowEnd: bool(false) } },
+  remove_edge: { fields: { index: num(false), id: str(false) }, requireOneOf: ["index", "id"] }
+};
+var XYCHART_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  set_x_axis: { fields: { axis: objOrNull() } },
+  set_y_axis: { fields: { axis: objOrNull() } },
+  add_series: { fields: { kind2: withNote(oneOf(SERIES_KINDS), "series type \u2014 the field is named kind2, not kind"), name: strOrNull(false), values: numArr() } },
+  remove_series: { fields: { index: num() } },
+  set_series_values: { fields: { index: num(), values: numArr() } },
+  set_series_name: { fields: { index: num(), name: strOrNull() } },
+  reorder_series: { fields: { from: num(), to: num() } },
+  set_orientation: { fields: { horizontal: withNote(bool(), "true = horizontal, false = vertical (the default)") } },
+  set_data_point: { fields: { seriesIndex: num(), index: withNote(num(), "0-based position within the series values"), value: withNote(num(), "finite") } }
+};
+var PIE_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  set_show_data: { fields: { showData: bool() } },
+  add_slice: { fields: { label: str(), value: withNote(num(), "> 0, finite") } },
+  remove_slice: { fields: { label: str() } },
+  rename_slice: { fields: { from: str(), to: str() } },
+  set_slice_value: { fields: { label: str(), value: withNote(num(), "> 0, finite") } },
+  reorder_slice: { fields: { from: num(), to: num() } }
+};
+var QUADRANT_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  set_axis_labels: { fields: { axis: oneOf(AXIS_KINDS), near: strOrNull(), far: strOrNull(false) } },
+  set_quadrant_label: { fields: { quadrant: num(), label: strOrNull() } },
+  add_point: { fields: { label: str(), x: withNote(num(), "0..1"), y: withNote(num(), "0..1") } },
+  remove_point: { fields: { label: str() } },
+  move_point: { fields: { label: str(), x: withNote(num(), "0..1"), y: withNote(num(), "0..1") } },
+  rename_point: { fields: { from: str(), to: str() } }
+};
+var GANTT_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  add_section: { fields: { label: str() } },
+  rename_section: { fields: { index: num(), label: str() } },
+  remove_section: { fields: { index: num() } },
+  add_task: { fields: { sectionIndex: num(), label: str(), taskId: str(false), tags: strArr(false), start: withNote(str(false), 'date, or "after <taskId>"'), end: withNote(str(), 'date, a duration like "3d", or "until <taskId>"'), index: withNote(num(false), "insert position; omit to append \u2014 inserting into an implicit-start chain re-chains the follower onto the new task") } },
+  remove_task: { fields: { sectionIndex: num(), taskIndex: num() } },
+  rename_task: { fields: { sectionIndex: num(), taskIndex: num(), label: str() } },
+  set_task_status: { fields: { sectionIndex: num(), taskIndex: num(), status: oneOf(GANTT_STATUSES, true, true) } },
+  set_task_dates: { fields: { sectionIndex: num(), taskIndex: num(), start: strOrNull(false), end: str(false) } },
+  set_task_flags: { fields: { sectionIndex: num(), taskIndex: num(), milestone: bool(false), vert: bool(false) } },
+  set_task_id: { fields: { sectionIndex: num(), taskIndex: num(), taskId: withNote(strOrNull(), "renames rewrite after/until references; null clears (rejected while referenced)") } },
+  move_task: { fields: { fromSection: num(), fromIndex: num(), toSection: num(), toIndex: withNote(num(), "insert position in the target section, applied after removal \u2014 rejected if the move would change an implicit-start task's predecessor") } },
+  move_section: { fields: { from: num(), to: num() } }
+};
+var MINDMAP_SCHEMA = {
+  add_node: { fields: { id: str(), label: str(), parent: str(), shape: oneOf(MINDMAP_SHAPES, false), index: num(false) } },
+  remove_node: { fields: { id: str(), recursive: bool(false) } },
+  rename_node: { fields: { from: str(), to: str() } },
+  set_label: { fields: { id: str(), label: str() } },
+  move_node: { fields: { id: str(), parent: str(), index: num(false) } },
+  set_shape: { fields: { id: str(), shape: oneOf(MINDMAP_SHAPES) } },
+  set_icon: { fields: { id: str(), icon: strOrNull() } },
+  set_node_class: { fields: { id: str(), className: strOrNull() } },
+  set_accessibility_title: { fields: { title: strOrNull() } },
+  set_accessibility_description: { fields: { description: strOrNull() } }
+};
+var GITGRAPH_SCHEMA = {
+  append_commit: { fields: { id: str(false), message: str(false), type: oneOf(GIT_COMMIT_TYPES, false), tags: strArr(false) } },
+  create_branch: { fields: { name: str(), order: num(false) } },
+  checkout_branch: { fields: { name: str() } },
+  merge_branch: { fields: { name: str(), id: str(false), type: oneOf(GIT_COMMIT_TYPES, false), tags: strArr(false) } },
+  cherry_pick: { fields: { id: str(), parent: str(false), tags: strArr(false) } },
+  set_commit_message: { fields: { id: str(), message: strOrNull() } },
+  set_commit_type: { fields: { id: str(), type: oneOf(GIT_COMMIT_TYPES) } },
+  set_commit_tags: { fields: { id: str(), tags: strArr() } },
+  rename_branch: { fields: { from: str(), to: str() } },
+  set_accessibility_title: { fields: { title: strOrNull() } },
+  set_accessibility_description: { fields: { description: strOrNull() } }
+};
+var RADAR_SCHEMA = {
+  set_title: { fields: { title: strOrNull() } },
+  add_axis: { fields: { id: str(), label: strOrNull(false), index: withNote(num(false), "insert position; omit to append"), fill: withNote(num(false), "value written to every existing curve for the new axis; default: min") } },
+  remove_axis: { fields: { id: str() } },
+  rename_axis: { fields: { from: str(), to: str() } },
+  set_axis_label: { fields: { id: str(), label: strOrNull() } },
+  reorder_axis: { fields: { from: num(), to: withNote(num(), "permutes every curve's value vector identically") } },
+  add_curve: { fields: { id: str(), label: strOrNull(false), values: withNote(numArr(), "one value per axis, in axis order"), index: num(false) } },
+  remove_curve: { fields: { id: str() } },
+  set_curve_values: { fields: { id: str(), values: withNote(numArr(), "length must equal the axis count") } },
+  set_curve_value: { fields: { curve: str(), axis: str(), value: withNote(num(), "non-negative, finite") } },
+  set_curve_label: { fields: { id: str(), label: strOrNull() } },
+  rename_curve: { fields: { from: str(), to: str() } },
+  reorder_curve: { fields: { from: num(), to: num() } },
+  set_config: { fields: { max: withNote(numOrNull(false), "> min; null resets auto-max"), min: withNote(numOrNull(false), "null resets 0"), ticks: withNote(numOrNull(false), `integer 1..${MAX_RADAR_TICKS}; null resets 5`), graticule: oneOf(GRATICULE_KINDS, false, true), showLegend: withNote(boolOrNull(false), "null resets true") } }
+};
+var SCHEMAS = {
+  flowchart: FLOWCHART_SCHEMA,
+  state: STATE_SCHEMA,
+  sequence: SEQUENCE_SCHEMA,
+  timeline: TIMELINE_SCHEMA,
+  class: CLASS_SCHEMA,
+  er: ER_SCHEMA,
+  journey: JOURNEY_SCHEMA,
+  architecture: ARCHITECTURE_SCHEMA,
+  xychart: XYCHART_SCHEMA,
+  pie: PIE_SCHEMA,
+  quadrant: QUADRANT_SCHEMA,
+  gantt: GANTT_SCHEMA,
+  mindmap: MINDMAP_SCHEMA,
+  gitgraph: GITGRAPH_SCHEMA,
+  radar: RADAR_SCHEMA
+};
+function hasOpSchema(family) {
+  return Object.hasOwn(SCHEMAS, family);
+}
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const d = Array.from({ length: m + 1 }, (_, i) => [i, ...Array(n).fill(0)]);
+  for (let j = 0; j <= n; j++) d[0][j] = j;
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+  return d[m][n];
+}
+function nearest(target, candidates) {
+  let best;
+  let bestD = Infinity;
+  for (const c of candidates) {
+    const dist = levenshtein(target.toLowerCase(), c.toLowerCase());
+    if (dist < bestD) {
+      bestD = dist;
+      best = c;
+    }
+  }
+  return best !== void 0 && bestD <= Math.max(2, Math.ceil(best.length * 0.4)) ? best : void 0;
+}
+function typeName(f) {
+  switch (f.type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "number-or-null":
+      return "number | null";
+    case "boolean-or-null":
+      return "boolean | null";
+    case "string-or-null":
+      return "string | null";
+    case "string-array":
+      return "string[]";
+    case "number-array":
+      return "number[]";
+    case "object-or-null":
+      return "object | null";
+    case "enum":
+      return `one of ${f.values.map((v) => JSON.stringify(v)).join(", ")}${f.nullable ? " | null" : ""}`;
+  }
+}
+function matchesType(spec, value) {
+  switch (spec.type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "number-or-null":
+      return value === null || typeof value === "number" && Number.isFinite(value);
+    case "boolean-or-null":
+      return value === null || typeof value === "boolean";
+    case "string-or-null":
+      return value === null || typeof value === "string";
+    case "string-array":
+      return Array.isArray(value) && value.every((v) => typeof v === "string");
+    case "number-array":
+      return Array.isArray(value) && value.every((v) => typeof v === "number" && Number.isFinite(v));
+    case "object-or-null":
+      return value === null || typeof value === "object" && !Array.isArray(value);
+    case "enum":
+      return spec.nullable === true && value === null || typeof value === "string" && spec.values.includes(value);
+  }
+}
+function admitOpRecord(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const snapshot = (input) => {
+    if (input === null || input === void 0 || typeof input === "string" || typeof input === "boolean" || typeof input === "number") return input;
+    if (typeof input !== "object") throw new TypeError("operation values must be plain JSON data");
+    if (seen.has(input)) throw new TypeError("operation data must not contain cycles");
+    seen.add(input);
+    try {
+      if (Array.isArray(input)) {
+        const prototype2 = Object.getPrototypeOf(input);
+        if (prototype2 !== Array.prototype) throw new TypeError("operation arrays must use the standard array prototype");
+        const descriptors2 = Object.getOwnPropertyDescriptors(input);
+        const length = descriptors2.length?.value;
+        if (!Number.isSafeInteger(length) || length < 0) throw new TypeError("operation arrays must have a readable length");
+        const keys = Reflect.ownKeys(input);
+        if (keys.some((key) => typeof key === "symbol" || key !== "length" && !/^(0|[1-9]\d*)$/.test(key))) {
+          throw new TypeError("operation arrays must not carry symbols or named properties");
+        }
+        const output2 = [];
+        for (let index = 0; index < length; index++) {
+          const descriptor = descriptors2[String(index)];
+          if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) {
+            throw new TypeError("operation arrays must be dense own-data arrays");
+          }
+          output2.push(snapshot(descriptor.value));
+        }
+        return output2;
+      }
+      const prototype = Object.getPrototypeOf(input);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError("operation records must be plain objects");
+      }
+      const descriptors = Object.getOwnPropertyDescriptors(input);
+      const output = /* @__PURE__ */ Object.create(null);
+      for (const key of Reflect.ownKeys(input)) {
+        if (typeof key === "symbol") throw new TypeError("operation records must not carry symbol keys");
+        const descriptor = descriptors[key];
+        if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) {
+          throw new TypeError("operation records must contain enumerable own data fields");
+        }
+        output[key] = snapshot(descriptor.value);
+      }
+      return output;
+    } finally {
+      seen.delete(input);
+    }
+  };
+  try {
+    return { ok: true, value: snapshot(value) };
+  } catch {
+    return { ok: false, message: "operation must be a plain own-data JSON object" };
+  }
+}
+function unreadableOp(family, message) {
+  return {
+    code: "INVALID_OP",
+    reason: "unreadable_op",
+    family,
+    message,
+    validFields: Object.keys(SCHEMAS[family])
+  };
+}
+function validateAdmittedOp(family, op) {
+  const schema = SCHEMAS[family];
+  if (Array.isArray(op)) {
+    return { code: "INVALID_OP", reason: "expected_single_op", family, message: unknownOpMessage(family, op), validFields: Object.keys(schema) };
+  }
+  if (!op || typeof op !== "object") {
+    return { code: "INVALID_OP", reason: "unknown_kind", family, message: unknownOpMessage(family, op), validFields: Object.keys(schema) };
+  }
+  const rec = op;
+  const kind = rec.kind;
+  if (typeof kind !== "string" || !Object.hasOwn(schema, kind)) {
+    const validKinds = Object.keys(schema);
+    const dym = typeof kind === "string" ? nearest(kind, validKinds) : void 0;
+    return {
+      code: "INVALID_OP",
+      reason: "unknown_kind",
+      family,
+      opKind: typeof kind === "string" ? kind : void 0,
+      message: `${unknownOpMessage(family, op)}${dym ? ` Did you mean "${dym}"?` : ""}`,
+      validFields: validKinds,
+      didYouMean: dym
+    };
+  }
+  const spec = schema[kind];
+  const validFields = Object.keys(spec.fields);
+  for (const key of Object.keys(rec)) {
+    if (key === "kind") continue;
+    if (!Object.hasOwn(spec.fields, key)) {
+      const dym = nearest(key, validFields);
+      return {
+        code: "INVALID_OP",
+        reason: "unknown_field",
+        family,
+        opKind: kind,
+        field: key,
+        message: `Unknown field "${key}" for ${family} op "${kind}".${dym ? ` Did you mean "${dym}"?` : ""} Valid fields: ${validFields.join(", ")}.`,
+        validFields,
+        didYouMean: dym
+      };
+    }
+  }
+  for (const [name, fspec] of Object.entries(spec.fields)) {
+    if (!fspec.required) continue;
+    if (rec[name] === void 0) {
+      return {
+        code: "INVALID_OP",
+        reason: "missing_field",
+        family,
+        opKind: kind,
+        field: name,
+        message: `Missing required field "${name}" (${typeName(fspec)}) for ${family} op "${kind}". Fields: ${validFields.join(", ")}.`,
+        validFields
+      };
+    }
+  }
+  if (spec.requireOneOf && !spec.requireOneOf.some((f) => rec[f] !== void 0)) {
+    return {
+      code: "INVALID_OP",
+      reason: "require_one_of",
+      family,
+      opKind: kind,
+      message: `${family} op "${kind}" requires at least one of: ${spec.requireOneOf.join(", ")}.`,
+      validFields
+    };
+  }
+  for (const [name, fspec] of Object.entries(spec.fields)) {
+    if (rec[name] === void 0) continue;
+    if (!matchesType(fspec, rec[name])) {
+      return {
+        code: "INVALID_OP",
+        reason: "wrong_type",
+        family,
+        opKind: kind,
+        field: name,
+        message: `Field "${name}" of ${family} op "${kind}" must be ${typeName(fspec)}, got ${JSON.stringify(rec[name])}.`,
+        validFields
+      };
+    }
+  }
+  return null;
+}
+function validateOp(family, op) {
+  const admitted = admitOpRecord(op);
+  if (!admitted.ok) return unreadableOp(family, admitted.message);
+  try {
+    return validateAdmittedOp(family, admitted.value);
+  } catch {
+    return unreadableOp(family, "operation could not be validated as plain JSON data");
+  }
+}
+function opMenu(family) {
+  if (!hasOpSchema(family)) {
+    throw new RangeError(`family must be one of: ${Object.keys(SCHEMAS).join(", ")}`);
+  }
+  const out = {};
+  for (const [kind, spec] of Object.entries(SCHEMAS[family])) {
+    out[kind] = Object.entries(spec.fields).map(([n, f]) => f.required ? n : `${n}?`);
+  }
+  return out;
+}
+function describeOps(family) {
+  if (!hasOpSchema(family)) {
+    throw new RangeError(`family must be one of: ${Object.keys(SCHEMAS).join(", ")}`);
+  }
+  const out = {};
+  for (const [kind, spec] of Object.entries(SCHEMAS[family])) {
+    out[kind] = Object.entries(spec.fields).map(([name, f]) => ({ name, required: f.required, type: typeName(f), ...f.note !== void 0 ? { note: f.note } : {} }));
+  }
+  return out;
+}
+function opSignatures(family) {
+  const menu = opMenu(family);
+  return Object.entries(menu).map(([kind, fields]) => `${kind}(${fields.join(", ")})`);
+}
+
+// src/agent/mutate.ts
+function mutate(d, op) {
+  const r = applyOneMutation(d, op);
+  logToolInvocation("mutate", r.ok);
+  return r;
+}
+function applyOneMutation(d, op) {
+  if (d.body.kind === "preserved") {
+    return err({
+      code: d.body.diagnostic.code === "UNKNOWN_HEADER" ? "UNKNOWN_HEADER" : "UNSUPPORTED_FAMILY",
+      message: `${d.body.diagnostic.message}; the exact source remains preserved and cannot accept structured mutation`
+    });
+  }
+  if (d.body.kind === "extension") {
+    return err({
+      code: "INVALID_OP",
+      message: `Registered external family "${d.kind}" has no typed mutation contract in FamilyDescriptor v2`
+    });
+  }
+  const plugin = getFamily(d.kind);
+  if (plugin?.mutate && plugin.serialize) {
+    const r = plugin.mutate(d.body, op);
+    if (!r.ok) return r;
+    const bodyAccessibility = accessibilityFromBody(r.value);
+    const meta = bodyAccessibility === void 0 ? d.meta : { ...d.meta, accessibility: bodyAccessibility };
+    const canonicalSource = wrapperPrefix(meta) + ensureAccessibilityLines(
+      plugin.serialize(r.value),
+      meta.accessibility
+    );
+    const reparsed = parseRegisteredMermaid(canonicalSource);
+    if (!reparsed.ok) {
+      return err({
+        code: "INVALID_OP",
+        message: `Mutation produced source that could not be reparsed: ${reparsed.error.map((error) => error.message).join("; ")}`
+      });
+    }
+    return ok({ ...d, body: r.value, meta, canonicalSource, source: reparsed.value.source });
+  }
+  return err({ code: "INVALID_OP", message: `Unsupported mutable diagram kind: ${d.kind}` });
+}
+function mutateChecked(d, op) {
+  if (hasOpSchema(d.kind)) {
+    const admitted = admitOpRecord(op);
+    const checkedOp = admitted.ok ? admitted.value : op;
+    const invalid = validateOp(d.kind, checkedOp);
+    if (invalid) {
+      logToolInvocation("mutate", false);
+      return err(invalid);
+    }
+    return mutate(d, checkedOp);
+  }
+  return mutate(d, op);
+}
+
+// src/agent/create.ts
+function emptyBody(kind, opts) {
+  switch (kind) {
+    case "flowchart":
+      return {
+        kind: "flowchart",
+        graph: {
+          direction: opts.direction ?? "TD",
+          nodes: /* @__PURE__ */ new Map(),
+          edges: [],
+          subgraphs: [],
+          classDefs: /* @__PURE__ */ new Map(),
+          classAssignments: /* @__PURE__ */ new Map(),
+          nodeStyles: /* @__PURE__ */ new Map(),
+          linkStyles: /* @__PURE__ */ new Map()
+        }
+      };
+    case "state":
+      return { kind: "state", states: [], transitions: [], direction: opts.direction };
+    case "sequence":
+      return { kind: "sequence", participants: [], messages: [], statements: [] };
+    case "timeline":
+      return { kind: "timeline", sections: [] };
+    case "class":
+      return { kind: "class", classes: [], relations: [], notes: [] };
+    case "er":
+      return { kind: "er", entities: [], relations: [] };
+    case "journey":
+      return { kind: "journey", sections: [] };
+    case "architecture":
+      return { kind: "architecture", groups: [], services: [], junctions: [], edges: [] };
+    case "xychart":
+      return { kind: "xychart", series: [] };
+    case "pie":
+      return { kind: "pie", showData: false, slices: [] };
+    case "quadrant":
+      return { kind: "quadrant", quadrants: [void 0, void 0, void 0, void 0], points: [] };
+    case "gantt":
+      return { kind: "gantt", sections: [], statements: [] };
+    case "mindmap":
+      return { kind: "mindmap", root: { id: "root", label: "root", shape: "default", children: [] } };
+    case "gitgraph":
+      return {
+        kind: "gitgraph",
+        direction: "LR",
+        mainBranchName: "main",
+        commits: [],
+        branches: [{ name: "main", order: 0, sequence: 0 }],
+        statements: []
+      };
+    case "radar":
+      return { kind: "radar", axes: [], curves: [], min: 0, ticks: 5, graticule: "circle", showLegend: true };
+  }
+}
+function createMermaid(kind, opts = {}) {
+  logToolInvocation("build");
+  const body = emptyBody(kind, opts);
+  if (!body) throw new Error(`createMermaid: unknown diagram kind "${String(kind)}"`);
+  const draft = {
+    kind,
+    body,
+    meta: { initDirectives: [], comments: [], accessibility: {} },
+    source: { nodes: /* @__PURE__ */ new Map(), edges: /* @__PURE__ */ new Map(), groups: /* @__PURE__ */ new Map(), labels: /* @__PURE__ */ new Map() },
+    canonicalSource: ""
+  };
+  return { ...draft, canonicalSource: serializeMermaid(draft) };
+}
+function buildMermaid(kind, ops, opts = {}) {
+  let d = createMermaid(kind, opts);
+  for (let i = 0; i < ops.length; i++) {
+    const r = mutate(d, ops[i]);
+    if (!r.ok) return err({ ...r.error, opIndex: i, message: `op[${i}] (${ops[i].kind}): ${r.error.message}` });
+    d = r.value;
+  }
+  return ok(d);
+}
+
+// src/agent/structural-count.ts
+function countStates(states) {
+  let nodes = 0, edges = 0;
+  for (const s of states) {
+    nodes++;
+    if (s.regions) {
+      for (const region of s.regions) {
+        const inner = countStates(region.states);
+        nodes += inner.nodes;
+        edges += inner.edges + region.transitions.length;
+      }
+    } else {
+      if (s.states && s.states.length) {
+        const inner = countStates(s.states);
+        nodes += inner.nodes;
+        edges += inner.edges;
+      }
+      if (s.transitions) edges += s.transitions.length;
+    }
+  }
+  return { nodes, edges };
+}
+function countSubgraphs(subgraphs) {
+  let groups = 0;
+  for (const sg of subgraphs) {
+    groups++;
+    groups += countSubgraphs(sg.children);
+  }
+  return groups;
+}
+function countStructuralElements(d) {
+  const body = d.body;
+  switch (body.kind) {
+    case "flowchart": {
+      const g = body.graph;
+      return { nodes: g.nodes.size, edges: g.edges.length, groups: countSubgraphs(g.subgraphs) };
+    }
+    case "sequence":
+      return { nodes: body.participants.length, edges: sequenceMessages(body).length, groups: 0 };
+    case "state": {
+      const top = countStates(body.states);
+      return { nodes: top.nodes, edges: top.edges + body.transitions.length, groups: 0 };
+    }
+    case "class":
+      return { nodes: body.classes.length, edges: body.relations.length, groups: (body.namespaces ?? []).length };
+    case "er":
+      return { nodes: body.entities.length, edges: body.relations.length, groups: (body.groups ?? []).length };
+    case "timeline": {
+      let nodes = 0;
+      for (const sec of body.sections) for (const p of sec.periods) nodes += 1 + p.events.length;
+      return { nodes, edges: 0, groups: body.sections.length };
+    }
+    case "journey": {
+      let nodes = 0;
+      for (const sec of body.sections) nodes += sec.tasks.length;
+      return { nodes, edges: 0, groups: body.sections.length };
+    }
+    case "architecture":
+      return {
+        nodes: body.services.length + body.junctions.length,
+        edges: body.edges.length,
+        groups: body.groups.length
+      };
+    case "xychart":
+      return { nodes: body.series.length, edges: 0, groups: 0 };
+    case "pie":
+      return { nodes: body.slices.length, edges: 0, groups: 0 };
+    case "quadrant":
+      return { nodes: body.points.length, edges: 0, groups: 0 };
+    case "gantt": {
+      let nodes = 0;
+      for (const sec of body.sections) nodes += sec.tasks.length;
+      return { nodes, edges: 0, groups: body.sections.length };
+    }
+    case "mindmap": {
+      let nodes = 0, edges = 0;
+      const visit2 = (node) => {
+        nodes++;
+        edges += node.children.length;
+        node.children.forEach(visit2);
+      };
+      visit2(body.root);
+      return { nodes, edges, groups: 0 };
+    }
+    case "gitgraph":
+      return {
+        nodes: body.commits.length,
+        edges: body.commits.reduce((sum, commit) => sum + commit.parents.length, 0),
+        groups: body.branches.length
+      };
+    case "radar":
+      return { nodes: body.curves.reduce((sum, c) => sum + c.values.length, 0), edges: 0, groups: body.axes.length };
+    case "opaque":
+    case "extension":
+    case "preserved":
+      return null;
+    default: {
+      const _never = body;
+      void _never;
+      return null;
+    }
+  }
+}
+function countsEqual(a, b) {
+  return a.nodes === b.nodes && a.edges === b.edges && a.groups === b.groups;
+}
+function faithfulnessWarning(before, after) {
+  if (!before) return [];
+  if (!after) return [{ code: "CONTENT_DROPPED_ON_ROUNDTRIP", before, after: { nodes: 0, edges: 0, groups: 0 } }];
+  if (!countsEqual(before, after)) return [{ code: "CONTENT_DROPPED_ON_ROUNDTRIP", before, after }];
+  return [];
+}
+
+// src/scene/brand-constraints.ts
+function visit(nodes, fn) {
+  for (const node of nodes) {
+    fn(node);
+    if (node.kind === "group") visit(node.children.map((child) => child.node), fn);
+  }
+}
+function mixOpaqueCss(foreground, background, percent) {
+  const fg = tryParseCssColor(foreground);
+  const bg = tryParseCssColor(background);
+  if (!fg || !bg || fg[3] !== 1 || bg[3] !== 1) return void 0;
+  const ratio = percent / 100;
+  return toHex(
+    fg[0] * ratio + bg[0] * (1 - ratio),
+    fg[1] * ratio + bg[1] * (1 - ratio),
+    fg[2] * ratio + bg[2] * (1 - ratio)
+  );
+}
+function resolvedPaint(value, request) {
+  if (!value) return void 0;
+  const colors = request.appearance.colors;
+  const mixed = (percent) => mixOpaqueCss(colors.fg, colors.bg, percent);
+  const derived = {
+    textSec: colors.muted ?? mixed(MIX.textSec),
+    textMuted: colors.muted ?? mixed(MIX.textMuted),
+    textFaint: mixed(MIX.textFaint),
+    line: colors.line ?? mixed(MIX.line),
+    arrow: colors.accent ?? mixed(MIX.arrow),
+    nodeFill: colors.surface ?? mixed(MIX.nodeFill),
+    nodeStroke: colors.border ?? mixed(MIX.nodeStroke),
+    groupHdr: mixed(MIX.groupHeader),
+    innerStroke: mixed(MIX.innerStroke),
+    keyBadge: mixed(MIX.keyBadge)
+  };
+  const styleOwnedToken = {
+    "--bg": colors.bg,
+    "--fg": colors.fg,
+    "--_text": colors.fg,
+    "--_text-sec": derived.textSec,
+    "--_text-muted": derived.textMuted,
+    "--_text-faint": derived.textFaint,
+    "--_line": derived.line,
+    "--_arrow": derived.arrow,
+    "--_node-fill": derived.nodeFill,
+    "--_node-stroke": derived.nodeStroke,
+    "--_group-fill": colors.bg,
+    "--_group-hdr": derived.groupHdr,
+    "--_inner-stroke": derived.innerStroke,
+    "--_key-badge": derived.keyBadge
+  };
+  const token = {
+    "--line": colors.line,
+    "--accent": colors.accent,
+    "--muted": colors.muted,
+    "--surface": colors.surface,
+    "--border": colors.border,
+    ...styleOwnedToken
+  };
+  const variable = value.match(/^var\(\s*(--[a-z0-9_-]+)(?:\s*,[\s\S]*)?\)$/i)?.[1];
+  return variable && Object.hasOwn(token, variable) ? token[variable] : value;
+}
+function warning(constraint, fields) {
+  return {
+    code: BRAND_CONSTRAINT_WARNING_POLICY[constraint.action].code,
+    constraint: constraint.kind,
+    ...fields,
+    message: `${fields.message} Recovery: ${BRAND_CONSTRAINT_DESCRIPTORS[constraint.kind].recovery}`
+  };
+}
+function sameChannels(a, b) {
+  const left = a.channels ?? {};
+  const right = b.channels ?? {};
+  const entries = (value) => Object.entries(value).sort(([a2], [b2]) => compareCodePointStrings(a2, b2));
+  return JSON.stringify(entries(left)) === JSON.stringify(entries(right));
+}
+function descendantText(nodes) {
+  const texts = [];
+  for (const node of nodes) {
+    if (node.kind === "text") texts.push(node);
+    else if (node.kind === "group") texts.push(...descendantText(node.children.map((child) => child.node)));
+  }
+  return texts;
+}
+function containsTextAnchors(shape, child) {
+  const bounds = geometryBounds(shape.geometry);
+  if (!bounds) return false;
+  const texts = descendantText([child]);
+  return texts.length > 0 && texts.every((text) => text.x >= bounds.x0 && text.x <= bounds.x1 && text.y >= bounds.y0 && text.y <= bounds.y1);
+}
+function childSurface(preceding, child, enclosingGroup) {
+  const last = (items) => items[items.length - 1];
+  return last(preceding.filter((shape) => shape.role === child.role && sameChannels(shape, child))) ?? (enclosingGroup ? last(preceding.filter((shape) => shape.role === enclosingGroup.role && sameChannels(shape, enclosingGroup))) : void 0) ?? last(preceding.filter((shape) => containsTextAnchors(shape, child)));
+}
+function collectTextContrastCandidates(nodes, inheritedBackground, candidates, role, enclosingGroup) {
+  const preceding = [];
+  for (const node of nodes) {
+    if (node.kind === "shape") {
+      if (node.paint.fill !== void 0 && node.paint.fill !== "none" && node.paint.fill !== "transparent") preceding.push(node);
+      continue;
+    }
+    const surface = childSurface(preceding, node, enclosingGroup);
+    const background = surface?.paint.fill ?? inheritedBackground;
+    if (node.kind === "text") {
+      if (!role || node.role === role) candidates.push({ node, background });
+      continue;
+    }
+    if (node.kind === "group") {
+      collectTextContrastCandidates(node.children.map((child) => child.node), background, candidates, role, node);
+    }
+  }
+}
+function contrastConstraint(constraint, scene, request) {
+  const minimum = constraint.minimum ?? 4.5;
+  if (request.renderOptions.transparent) {
+    return warning(constraint, {
+      measurement: "unmeasurable",
+      minimum,
+      message: "Final contrast is unmeasurable for transparent output because the host backdrop is unknown; no ratio was fabricated."
+    });
+  }
+  const pageBackground = resolvedPaint(request.appearance.colors.bg, request);
+  const candidates = [];
+  collectTextContrastCandidates(scene.parts, pageBackground, candidates, constraint.role);
+  if (candidates.length === 0) {
+    return warning(constraint, {
+      measurement: "not-applicable",
+      minimum,
+      ...constraint.role ? { role: constraint.role } : {},
+      message: `Contrast constraint has no applicable text mark${constraint.role ? ` for role ${constraint.role}` : ""}.`
+    });
+  }
+  const measured = candidates.map((candidate) => {
+    const foreground = resolvedPaint(candidate.node.paint.fill, request);
+    const background = resolvedPaint(candidate.background, request);
+    const ratio = foreground && background ? wcagCssContrastRatio(foreground, background, pageBackground) : null;
+    return { ...candidate, foreground, background, ratio };
+  });
+  const worst = measured.filter((candidate) => candidate.ratio !== null).sort((a, b) => a.ratio - b.ratio)[0];
+  if (worst && worst.ratio < minimum) {
+    const rounded2 = Math.round(worst.ratio * 100) / 100;
+    return warning(constraint, {
+      measurement: "measurable",
+      minimum,
+      ratio: rounded2,
+      role: worst.node.role,
+      mark: worst.node.id,
+      foreground: worst.foreground,
+      background: worst.background,
+      message: `Final ${worst.node.role} contrast is ${rounded2}:1; expected at least ${minimum}:1. Paint remains unchanged.`
+    });
+  }
+  const unresolved = measured.find((candidate) => candidate.ratio === null);
+  if (unresolved) {
+    return warning(constraint, {
+      measurement: "unmeasurable",
+      minimum,
+      role: unresolved.node.role,
+      mark: unresolved.node.id,
+      ...unresolved.foreground ? { foreground: unresolved.foreground } : {},
+      ...unresolved.background ? { background: unresolved.background } : {},
+      message: "Final contrast is unmeasurable because an effective paint pair is unresolved; no ratio was fabricated."
+    });
+  }
+  const rounded = Math.round(worst.ratio * 100) / 100;
+  return warning(constraint, {
+    measurement: "measurable",
+    minimum,
+    ratio: rounded,
+    role: worst.node.role,
+    mark: worst.node.id,
+    foreground: worst.foreground,
+    background: worst.background,
+    message: `Final ${worst.node.role} contrast is ${rounded}:1 and meets ${minimum}:1.`
+  });
+}
+function sameConcretePaint(left, right) {
+  const a = tryParseCssColor(left);
+  const b = tryParseCssColor(right);
+  if (!a || !b) return left.trim().toLowerCase() === right.trim().toLowerCase();
+  return a.every((channel, index) => Math.abs(channel - b[index]) < 1e-6);
+}
+function accentAreaConstraint(constraint, scene, request) {
+  const accent = resolvedPaint(request.appearance.colors.accent, request);
+  if (!accent) return warning(constraint, {
+    measurement: "unmeasurable",
+    maximum: constraint.maxFraction,
+    message: "Accent-area constraint is unmeasurable because no concrete accent paint is resolved."
+  });
+  let total = 0;
+  let accented = 0;
+  visit(scene.parts, (node) => {
+    if (node.kind !== "shape" || node.role === "chrome") return;
+    const fill = resolvedPaint(node.paint.fill, request);
+    if (!fill || fill === "none" || fill === "transparent") return;
+    const bounds = geometryBounds(node.geometry);
+    if (!bounds) return;
+    const area = Math.max(0, bounds.x1 - bounds.x0) * Math.max(0, bounds.y1 - bounds.y0);
+    total += area;
+    if (sameConcretePaint(fill, accent)) accented += area;
+  });
+  if (total === 0) return warning(constraint, {
+    measurement: "not-applicable",
+    maximum: constraint.maxFraction,
+    message: "Accent-area constraint has no applicable filled shape area."
+  });
+  const actual = Math.round(accented / total * 1e4) / 1e4;
+  return warning(constraint, {
+    measurement: "measurable",
+    actual,
+    maximum: constraint.maxFraction,
+    message: actual > constraint.maxFraction ? `Accent fill covers ${(actual * 100).toFixed(2)}% of applicable shape area; maximum is ${(constraint.maxFraction * 100).toFixed(2)}%. Paint remains unchanged.` : `Accent fill area is within the configured maximum.`
+  });
+}
+function monoRoleConstraint(constraint, scene, request) {
+  const paints = [];
+  visit(scene.parts, (node) => {
+    if (node.role !== constraint.role) return;
+    const values = node.kind === "connector" ? [node.stroke.color] : "paint" in node ? [node.paint.fill, node.paint.stroke] : [];
+    for (const value of values) {
+      const paint = resolvedPaint(value, request);
+      if (paint && paint !== "none") paints.push({ mark: node.id, value: paint });
+    }
+  });
+  if (paints.length === 0) return warning(constraint, {
+    measurement: "not-applicable",
+    role: constraint.role,
+    message: `Mono-role constraint has no applicable paint for role ${constraint.role}.`
+  });
+  for (const paint of paints) {
+    const parsed = tryParseCssColor(paint.value);
+    if (!parsed) return warning(constraint, {
+      measurement: "unmeasurable",
+      role: constraint.role,
+      mark: paint.mark,
+      message: `Mono-role paint ${paint.value} is unresolved; no monochrome verdict was fabricated.`
+    });
+    if (Math.abs(parsed[0] - parsed[1]) > 1 || Math.abs(parsed[1] - parsed[2]) > 1) {
+      return warning(constraint, {
+        measurement: "measurable",
+        role: constraint.role,
+        mark: paint.mark,
+        foreground: paint.value,
+        message: `Role ${constraint.role} uses chromatic paint ${paint.value}; the mono-role constraint does not repaint it.`
+      });
+    }
+  }
+  return warning(constraint, {
+    measurement: "measurable",
+    role: constraint.role,
+    message: `Role ${constraint.role} uses only measurable monochrome paint.`
+  });
+}
+var CONSTRAINT_EVALUATORS = {
+  contrast: contrastConstraint,
+  "accent-area": accentAreaConstraint,
+  "mono-role": monoRoleConstraint
+};
+function evaluateConstraint(constraint, scene, request) {
+  const evaluator = CONSTRAINT_EVALUATORS[constraint.kind];
+  return evaluator(constraint, scene, request);
+}
+function evaluateBrandConstraints(scene, request) {
+  const constraints = request.appearance.style?.constraints ?? [];
+  const results = constraints.map((constraint) => evaluateConstraint(constraint, scene, request)).filter((warning2) => {
+    if (warning2.measurement !== "measurable") return true;
+    if (warning2.constraint === "contrast") return (warning2.ratio ?? Infinity) < (warning2.minimum ?? 4.5);
+    if (warning2.constraint === "accent-area") return (warning2.actual ?? 0) > (warning2.maximum ?? 1);
+    return warning2.foreground !== void 0;
+  });
+  return results;
+}
+
+// src/agent/verify.ts
+function familyConfigShapeWarnings(d) {
+  const roots = [d.meta.frontmatter, ...d.meta.initDirectives.map((directive) => directive.parsed)];
+  return familyConfigDiagnostics(d.kind, roots);
+}
+var KNOWN_SHAPES = /* @__PURE__ */ new Set([
+  "rectangle",
+  "service",
+  "rounded",
+  "diamond",
+  "stadium",
+  "circle",
+  "subroutine",
+  "doublecircle",
+  "hexagon",
+  "cylinder",
+  "asymmetric",
+  "trapezoid",
+  "trapezoid-alt",
+  "lean-r",
+  "lean-l",
+  "state-start",
+  "state-end",
+  "state-fork",
+  "state-join",
+  "state-choice",
+  "state-history"
+]);
+function opaqueSourceHasOnlyHeader(kind, source) {
+  const statements = source.split(/[;\n]/).map((part) => part.trim()).filter((part) => part && !part.startsWith("%%"));
+  if (statements.length === 0) return true;
+  if (statements.length > 1) return false;
+  const header = statements[0].toLowerCase();
+  const aliases = (builtinFamilyMetadata(kind)?.headers ?? [kind]).map((h) => h.toLowerCase());
+  return aliases.some((alias) => header === alias || header.startsWith(`${alias} `));
+}
+function roundtripFaithfulnessWarnings(d) {
+  const before = countStructuralElements(d);
+  if (!before) return [];
+  try {
+    const reparsed = parseRegisteredMermaid(serializeMermaid(d));
+    if (!reparsed.ok) return faithfulnessWarning(before, null);
+    const after = countStructuralElements(reparsed.value);
+    if (!after) return [];
+    return faithfulnessWarning(before, after);
+  } catch {
+    return [];
+  }
+}
+function verifyMermaid(input, opts = {}) {
+  logToolInvocation("verify");
+  const parsed = typeof input === "string" ? parseRegisteredMermaid(input) : { ok: true, value: input };
+  if (!parsed.ok) {
+    const sourceWarnings = typeof input === "string" ? flowchartUnsupportedSyntaxWarnings(input) : [];
+    return finalize([{ code: "EMPTY_DIAGRAM" }, ...sourceWarnings], emptyRenderedLayout("flowchart"), opts);
+  }
+  if (parsed.value.body.kind === "preserved") {
+    const { diagnostic } = parsed.value.body;
+    return finalize(
+      [{ code: "RENDER_FAILED", reason: `${diagnostic.code}: ${diagnostic.message}` }],
+      emptyRenderedLayout(parsed.value.kind),
+      opts,
+      false
+    );
+  }
+  const positioned = memoizedVerificationArtifact(parsed.value, opts);
+  try {
+    const structured = verifyStructure(parsed.value, opts, positioned);
+    return withRenderParity(withBrandConstraints(structured, opts, positioned), opts, positioned);
+  } catch (error) {
+    if (!(error instanceof FamilyLayoutError)) throw error;
+    return finalize(
+      [{ code: "RENDER_FAILED", reason: error.message }],
+      emptyRenderedLayout(parsed.value.kind),
+      opts,
+      false
+    );
+  }
+}
+function withBrandConstraints(result, opts, positioned) {
+  if (!result.ok) return result;
+  try {
+    const artifact = positioned();
+    const constraints = artifact?.request.appearance.style?.constraints;
+    if (!artifact || !constraints || constraints.length === 0) return result;
+    const scene = lowerPositionedFamilyScene(artifact.request, artifact.layoutResult);
+    const suppressed = new Set(opts.suppress ?? []);
+    const warnings = evaluateBrandConstraints(scene, artifact.request).filter((warning2) => !suppressed.has(warning2.code));
+    return {
+      ...result,
+      ok: result.ok && !warnings.some((warning2) => WARNING_SEVERITY[warning2.code] === "error"),
+      warnings: [...result.warnings, ...warnings]
+    };
+  } catch {
+    return result;
+  }
+}
+function memoizedVerificationArtifact(d, opts) {
+  let attempted = false;
+  let artifact = null;
+  let failure;
+  return () => {
+    if (attempted) {
+      if (failure !== void 0) throw failure;
+      return artifact;
+    }
+    attempted = true;
+    try {
+      artifact = positionFamilyArtifact(d, {
+        renderOptions: opts.renderOptions,
+        output: "svg"
+      });
+      return artifact;
+    } catch (error) {
+      failure = error;
+      throw error;
+    }
+  };
+}
+function withRenderParity(result, opts, positioned) {
+  if (!result.ok || (opts.suppress ?? []).some((code) => code === "RENDER_FAILED" || WARNING_SEVERITY[code] === "error")) return result;
+  try {
+    const artifact = positioned();
+    if (!artifact) throw new Error(`Mermaid family "${result.layout.kind}" has no positioned graphical artifact`);
+    renderPositionedMermaidSVG(artifact.request, artifact.layoutResult, []);
+    return result;
+  } catch (e) {
+    const reason = e instanceof Error ? e.message : String(e);
+    return { ...result, ok: false, warnings: [...result.warnings, { code: "RENDER_FAILED", reason }] };
+  }
+}
+function ganttTodayMarkerWarnings(d) {
+  try {
+    const normalized = normalizeMermaidSource(d.canonicalSource);
+    const model = applyGanttFrontmatterConfig(parseGanttModel(normalized.lines), normalized.frontmatter);
+    const payload = model.todayMarker?.style;
+    if (payload === void 0) return [];
+    return [...parseTodayMarkerStyle(payload).ignored].sort().map((prop) => ({
+      code: "INEFFECTIVE_CONFIG",
+      field: `todayMarker.${prop}`,
+      message: `Gantt todayMarker style property "${prop}" is accepted for Mermaid compatibility but is not applied to the today line (wired, sanitized properties: ${GANTT_TODAY_MARKER_STYLE_PROPS.join(", ")}).`
+    }));
+  } catch {
+    return [];
+  }
+}
+function flowchartShapeSubstitutionWarnings(d) {
+  if (d.kind !== "flowchart" || d.body.kind !== "flowchart") return [];
+  const warnings = [];
+  for (const node of d.body.graph.nodes.values()) {
+    if (!node.semanticShape) continue;
+    const v11 = normalizeV11Shape(node.semanticShape);
+    if (!v11 || v11.exact) continue;
+    warnings.push({
+      code: "UNSUPPORTED_SYNTAX",
+      syntax: "flowchart_shape_substitution",
+      node: node.id,
+      message: `Mermaid v11 shape "${node.authoredShape ?? node.semanticShape}" (${v11.description}) has no dedicated renderer yet; node "${node.id}" renders with the nearest geometry "${v11.geometry}".`
+    });
+  }
+  return warnings;
+}
+function quadrantInertStyleWarnings(d) {
+  if (d.body.kind !== "quadrant") return [];
+  const inert = /* @__PURE__ */ new Set();
+  const collect = (style) => {
+    for (const entry of style?.extra ?? []) inert.add(entry.slice(0, entry.indexOf(":")).trim());
+  };
+  for (const point of d.body.points) collect(point.style);
+  for (const style of Object.values(d.body.classDefs ?? {})) collect(style);
+  return [...inert].sort().map((property) => ({
+    code: "UNSUPPORTED_SYNTAX",
+    syntax: "quadrant_style_property",
+    message: `Quadrant style property "${property}" is preserved in source for upstream compatibility but has no effect on rendered points (rendered properties: radius, color, stroke-color, stroke-width).`
+  }));
+}
+function radarAuthoredContrastWarnings(positioned) {
+  try {
+    const artifact = positioned();
+    if (artifact?.request.renderOptions.transparent) return [];
+    const visual = artifact?.request.familyConfig?.visual;
+    const foreground = visual?.axisColor;
+    if (typeof foreground !== "string") return [];
+    const background = artifact.request.appearance.colors.bg;
+    const ratio = wcagCssContrastRatio(foreground, background);
+    if (ratio === null || ratio >= 4.5) return [];
+    const roundedRatio = Math.round(ratio * 100) / 100;
+    return [{
+      code: "LOW_CONTRAST",
+      field: "themeVariables.radar.axisColor",
+      foreground,
+      background,
+      ratio: roundedRatio,
+      minimum: 4.5,
+      message: `Authored Radar axis label color ${foreground} has contrast ${roundedRatio}:1 against ${background}; expected at least 4.5:1. The color is preserved as authored.`
+    }];
+  } catch {
+    return [];
+  }
+}
+function configWarningsForDiagram(d) {
+  if (d.body.kind === "extension" || d.body.kind === "preserved") return [];
+  const builtin = d;
+  const familySpecific = builtin.kind === "gantt" ? ganttTodayMarkerWarnings(builtin) : [];
+  return dedupedConcat(familySpecific, familyConfigShapeWarnings(builtin));
+}
+function configWarningsForMermaid(source) {
+  const parsed = parseRegisteredMermaid(source);
+  return parsed.ok ? configWarningsForDiagram(parsed.value) : [];
+}
+function verifyStructure(parsed, opts, positioned) {
+  const cap = opts.labelCharCap ?? DEFAULT_LABEL_CHAR_CAP;
+  const metaWarnings = parsed.meta.droppedComments?.length ? [{ code: "COMMENT_DROPPED", count: parsed.meta.droppedComments.length, lines: parsed.meta.droppedComments.map((c) => c.line) }] : [];
+  const dispatchedWarnings = dispatchFamilyVerify(parsed, opts);
+  if (parsed.body.kind === "extension") {
+    return verifyExtension(parsed, cap, opts, dedupedConcat(metaWarnings, dispatchedWarnings), positioned);
+  }
+  const d = parsed;
+  const sourceWarnings = d.kind === "flowchart" ? dedupedConcat(flowchartUnsupportedSyntaxWarnings(d.canonicalSource), flowchartShapeSubstitutionWarnings(d)) : d.kind === "er" ? erUnsupportedSyntaxWarnings(d.canonicalSource) : d.kind === "quadrant" ? quadrantInertStyleWarnings(d) : [];
+  const faithfulnessWarnings = roundtripFaithfulnessWarnings(d);
+  const configWarnings = configWarningsForDiagram(d);
+  let pluginWarnings = dedupedConcat(dedupedConcat(dedupedConcat(dedupedConcat(metaWarnings, dispatchedWarnings), sourceWarnings), faithfulnessWarnings), configWarnings);
+  if (d.body.kind === "class" && (d.meta.accessibility.title !== void 0 || d.meta.accessibility.descr !== void 0)) {
+    pluginWarnings = pluginWarnings.filter((warning2) => warning2.code !== "EMPTY_DIAGRAM");
+  }
+  if (d.body.kind === "sequence") return mergeFinalize(verifySequence(d, cap, opts, positioned), pluginWarnings, opts);
+  if (d.body.kind === "timeline") return mergeFinalize(verifyTimeline(d, cap, opts, positioned), pluginWarnings, opts);
+  if (d.body.kind === "gantt") {
+    const schedFail = ganttScheduleWarning(d);
+    if (schedFail) {
+      return finalize(
+        dedupedConcat(pluginWarnings, [schedFail]),
+        emptyRenderedLayout(d.kind),
+        opts,
+        false
+      );
+    }
+    const layoutOutcome = familyLayoutForVerify(d, positioned);
+    const layout = layoutOutcome.layout;
+    const geometric = dedupedConcat(
+      ganttGeometryWarnings(layout),
+      layoutOutcome.warnings
+    );
+    return finalize(dedupedConcat(pluginWarnings, geometric), layout, opts);
+  }
+  if (d.body.kind === "class" || d.body.kind === "er" || d.body.kind === "journey" || d.body.kind === "architecture" || d.body.kind === "xychart" || d.body.kind === "pie" || d.body.kind === "quadrant" || d.body.kind === "mindmap" || d.body.kind === "gitgraph" || d.body.kind === "radar") {
+    const layoutOutcome = familyLayoutForVerify(d, positioned);
+    const layout = layoutOutcome.layout;
+    const familyGeometry = d.body.kind === "class" || d.body.kind === "er" ? layoutGeometryWarnings(layout, { edgeAnchors: true, nodeOverlaps: true, groupContainment: d.body.kind === "class" }) : layoutGeometryWarnings(layout, {
+      nodeOverlaps: d.body.kind === "journey",
+      // Journey sections are groups with task members (family-layouts.ts),
+      // so a task laid outside its section band is a reportable breach.
+      groupContainment: d.body.kind === "xychart" || d.body.kind === "quadrant" ? "center" : d.body.kind === "journey"
+    });
+    const appearanceWarnings = d.body.kind === "radar" ? radarAuthoredContrastWarnings(positioned) : [];
+    return finalize(
+      dedupedConcat(dedupedConcat(dedupedConcat(pluginWarnings, familyGeometry), layoutOutcome.warnings), appearanceWarnings),
+      layout,
+      opts
+    );
+  }
+  if (d.body.kind === "state") {
+    const graph2 = stateBodyToGraph(d.body);
+    if (graph2.nodes.size === 0) return finalize(dedupedConcat([{ code: "EMPTY_DIAGRAM" }], pluginWarnings), emptyRenderedLayout(d.kind), opts);
+    const { warnings, layout } = verifyGraph(graph2, d, cap, positioned);
+    return finalize(dedupedConcat(warnings, pluginWarnings), layout, opts);
+  }
+  if (d.body.kind === "opaque") {
+    const isEmpty = opaqueSourceHasOnlyHeader(d.kind, d.body.source);
+    const plugin = getFamily(d.kind);
+    const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+    const warnings = isEmpty ? [{ code: "EMPTY_DIAGRAM" }] : [];
+    if (!isEmpty && !pluginWarnings.some((w) => w.code === "UNSUPPORTED_SYNTAX")) {
+      warnings.push({
+        code: "UNSUPPORTED_SYNTAX",
+        syntax: `${d.kind}_opaque`,
+        message: `This ${d.kind} diagram uses syntax the structured parser does not model; it is preserved verbatim as source. Typed mutation (the ${d.kind} \`as*\` narrower) is unavailable \u2014 edit the source directly, or verify/render it as-is.`
+      });
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const lbl of labels) {
+      const w = labelOverflowWarning(lbl.target, lbl.text, cap);
+      if (!w) continue;
+      const key = `${lbl.target}:${lbl.text}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      warnings.push(w);
+    }
+    const layoutOutcome = familyLayoutForVerify(d, positioned);
+    const opaqueLayout = layoutOutcome.layout;
+    return finalize(dedupedConcat(dedupedConcat(warnings, pluginWarnings), layoutOutcome.warnings), opaqueLayout, opts, false);
+  }
+  const graph = d.body.graph;
+  if (graph.nodes.size === 0) return finalize([{ code: "EMPTY_DIAGRAM" }], emptyRenderedLayout(d.kind), opts);
+  const { warnings: graphWarnings, layout: graphLayout } = verifyGraph(graph, d, cap, positioned);
+  return finalize(dedupedConcat(graphWarnings, pluginWarnings), graphLayout, opts);
+}
+function verifyExtension(d, cap, opts, initialWarnings, positioned) {
+  const warnings = [...initialWarnings];
+  const descriptor = getFamily(d.kind);
+  const labels = (descriptor?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+  const seenLabels = /* @__PURE__ */ new Set();
+  for (const label of labels) {
+    const warning2 = labelOverflowWarning(label.target, label.text, cap);
+    if (!warning2) continue;
+    const key = `${label.target}:${label.text}`;
+    if (seenLabels.has(key)) continue;
+    seenLabels.add(key);
+    warnings.push(warning2);
+  }
+  const layoutOutcome = familyLayoutForVerify(d, positioned);
+  return finalize([...warnings, ...layoutOutcome.warnings], layoutOutcome.layout, opts, false);
+}
+function familyLayoutForVerify(d, positioned) {
+  try {
+    const artifact = positioned();
+    return artifact ? { layout: artifact.rendered, warnings: [] } : {
+      layout: emptyRenderedLayout(d.kind),
+      warnings: [{
+        code: "RENDER_FAILED",
+        reason: `Mermaid family "${d.kind}" has no public layout projection registered`
+      }]
+    };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return {
+      layout: emptyRenderedLayout(d.kind),
+      warnings: [{ code: "RENDER_FAILED", reason }]
+    };
+  }
+}
+function verifyGraph(graph, d, cap, positionedArtifact) {
+  let artifact;
+  try {
+    artifact = positionedArtifact();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { warnings: [{ code: "RENDER_FAILED", reason }], layout: emptyRenderedLayout(d.kind) };
+  }
+  if (!artifact || !isPositionedGraph(artifact.positioned)) {
+    return {
+      warnings: [{ code: "UNSUPPORTED_SYNTAX", syntax: "positioned_artifact", message: `The ${d.kind} family did not produce its declared positioned-graph artifact.` }],
+      layout: emptyRenderedLayout(d.kind)
+    };
+  }
+  const positioned = artifact.positioned;
+  const layout = artifact.rendered;
+  const warnings = [];
+  for (const edge of graph.edges) {
+    const hasSource = graph.nodes.has(edge.source) || Boolean(findSubgraphById(graph.subgraphs, edge.source));
+    const hasTarget = graph.nodes.has(edge.target) || Boolean(findSubgraphById(graph.subgraphs, edge.target));
+    if (!hasSource || !hasTarget) {
+      warnings.push({
+        code: "EDGE_MISANCHORED",
+        edge: `${edge.source}->${edge.target}`,
+        from: hasSource ? edge.source : void 0,
+        to: hasTarget ? edge.target : void 0
+      });
+    }
+  }
+  for (const [id, node] of graph.nodes) {
+    if (!KNOWN_SHAPES.has(node.shape)) warnings.push({ code: "UNKNOWN_SHAPE", node: id, shape: String(node.shape) });
+    const w = labelOverflowWarning(id, node.label, cap);
+    if (w) warnings.push(w);
+  }
+  for (const edge of graph.edges) {
+    const w = edge.label ? labelOverflowWarning(`${edge.source}->${edge.target}`, edge.label, cap) : null;
+    if (w) warnings.push(w);
+  }
+  for (const n of positioned.nodes) {
+    if (n.x < 0 || n.x + n.width > positioned.width + 1) warnings.push({ code: "OFF_CANVAS", target: n.id, axis: "x" });
+    if (n.y < 0 || n.y + n.height > positioned.height + 1) warnings.push({ code: "OFF_CANVAS", target: n.id, axis: "y" });
+  }
+  for (const g of positioned.groups) {
+    const visit2 = (group) => {
+      const sg = findSubgraphById(graph.subgraphs, group.id);
+      if (sg) for (const n of positioned.nodes) {
+        if (!sg.nodeIds.includes(n.id)) continue;
+        const inside = n.x >= group.x && n.y >= group.y && n.x + n.width <= group.x + group.width + 0.5 && n.y + n.height <= group.y + group.height + 0.5;
+        if (!inside) warnings.push({ code: "GROUP_BREACH", group: group.id, member: n.id });
+      }
+      for (const c of group.children) visit2(c);
+    };
+    visit2(g);
+  }
+  for (let i = 0; i < positioned.nodes.length; i++) {
+    for (let j = i + 1; j < positioned.nodes.length; j++) {
+      const a = positioned.nodes[i], b = positioned.nodes[j];
+      const o = rectIntersection(a, b);
+      if (o > 0) warnings.push({ code: "NODE_OVERLAP", a: a.id, b: b.id, areaPx: Math.round(o) });
+    }
+  }
+  for (const e of positioned.edges) {
+    const c = countSelfCrossings(e.points);
+    if (c > 0) warnings.push({ code: "ROUTE_SELF_CROSS", edge: `${e.source}->${e.target}`, count: c });
+  }
+  for (const hitch of findRouteHitches(positioned, graph)) {
+    warnings.push({ code: "ROUTE_HITCH", edge: hitch.edge, deviationPx: hitch.deviationPx });
+  }
+  warnings.push(...auditRouteContracts(positioned, graph));
+  warnings.push(...lintFlowchartGraph(graph));
+  return { warnings, layout };
+}
+function dedupedConcat(a, b) {
+  if (b.length === 0) return a;
+  const seen = new Set(a.map(warningKey));
+  const novel = b.filter((w) => !seen.has(warningKey(w)));
+  return novel.length === 0 ? a : [...a, ...novel];
+}
+function dispatchFamilyVerify(d, opts) {
+  const plugin = getFamily(d.kind);
+  if (!plugin?.verify) return d.body.kind === "extension" ? [{ code: "RENDER_FAILED", reason: `Mermaid family "${d.kind}" has no verify hook registered` }] : [];
+  try {
+    let body = d.body;
+    if (d.body.kind === "extension") {
+      const extension = d;
+      if (!sameExtensionIdentity(extension.descriptorIdentity, plugin.identity)) {
+        const reparsed = parseRegisteredMermaid(serializeMermaid(d));
+        if (!reparsed.ok || reparsed.value.kind !== d.kind || reparsed.value.body.kind !== "extension") {
+          return [{
+            code: "RENDER_FAILED",
+            reason: `Mermaid family "${d.kind}" could not reparse source under its current descriptor before verification`
+          }];
+        }
+        body = reparsed.value.body;
+      }
+    }
+    return plugin.verify(body, opts);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return [{ code: "RENDER_FAILED", reason: `Mermaid family "${d.kind}" verify hook failed: ${reason}` }];
+  }
+}
+function mergeFinalize(prev, extra, opts) {
+  if (extra.length === 0) return prev;
+  const merged = dedupedConcat(prev.warnings, extra);
+  if (merged === prev.warnings) return prev;
+  return finalize(merged, prev.layout, opts, false);
+}
+function warningKey(w) {
+  if (w.code === "UNSUPPORTED_SYNTAX") return `${w.code}:${w.syntax}:${w.line ?? ""}:${w.node ?? ""}`;
+  if (w.code === "RENDER_FAILED") return `${w.code}:${w.reason}`;
+  if ("target" in w) return `${w.code}:${w.target}`;
+  if ("edge" in w) return `${w.code}:${w.edge}`;
+  if ("node" in w) return `${w.code}:${w.node}`;
+  if ("group" in w) return `${w.code}:${w.group}`;
+  if ("a" in w && "b" in w) return `${w.code}:${w.a}|${w.b}`;
+  return w.code;
+}
+function lintFlowchartGraph(graph) {
+  const warnings = [];
+  const firstBySignature = /* @__PURE__ */ new Map();
+  graph.edges.forEach((edge, index) => {
+    const signature = JSON.stringify({
+      source: edge.source,
+      target: edge.target,
+      label: edge.label ?? "",
+      style: edge.style,
+      hasArrowStart: edge.hasArrowStart,
+      hasArrowEnd: edge.hasArrowEnd,
+      startMarker: edge.startMarker ?? "arrow",
+      endMarker: edge.endMarker ?? "arrow"
+    });
+    const id = `${edge.source}->${edge.target}#${index}`;
+    const first = firstBySignature.get(signature);
+    if (first) {
+      warnings.push({ code: "DUPLICATE_EDGE", edge: id, duplicateOf: first.edge, from: edge.source, to: edge.target, label: edge.label });
+    } else {
+      firstBySignature.set(signature, { edge: id, from: edge.source, to: edge.target, label: edge.label });
+    }
+  });
+  const outEdges = /* @__PURE__ */ new Map();
+  graph.edges.forEach((edge, index) => {
+    const node = graph.nodes.get(edge.source);
+    if (!node || node.shape !== "diamond" || edge.source === edge.target) return;
+    const entry = outEdges.get(edge.source) ?? { labeled: 0, unlabeled: [] };
+    if (edge.label && edge.label.trim().length > 0) entry.labeled++;
+    else entry.unlabeled.push(`${edge.source}->${edge.target}#${index}`);
+    outEdges.set(edge.source, entry);
+  });
+  for (const [nodeId, entry] of outEdges) {
+    if (entry.labeled + entry.unlabeled.length < 2) continue;
+    for (const edge of entry.unlabeled) {
+      warnings.push({ code: "DECISION_BRANCH_UNLABELED", node: nodeId, edge });
+    }
+  }
+  const ids = Array.from(graph.nodes.keys());
+  if (ids.length === 0 || graph.edges.length === 0) return warnings;
+  const incoming = new Map(ids.map((id) => [id, 0]));
+  const outgoing = new Map(ids.map((id) => [id, []]));
+  for (const edge of graph.edges) {
+    if (!graph.nodes.has(edge.source) || !graph.nodes.has(edge.target)) continue;
+    incoming.set(edge.target, (incoming.get(edge.target) ?? 0) + 1);
+    outgoing.get(edge.source).push(edge.target);
+  }
+  const roots = ids.filter((id) => (incoming.get(id) ?? 0) === 0);
+  if (roots.length === 0) return warnings;
+  const seen = new Set(roots);
+  const queue = [...roots];
+  for (let i = 0; i < queue.length; i++) {
+    for (const next of outgoing.get(queue[i]) ?? []) {
+      if (seen.has(next)) continue;
+      seen.add(next);
+      queue.push(next);
+    }
+  }
+  for (const id of ids) {
+    if (!seen.has(id)) warnings.push({ code: "UNREACHABLE_NODE", node: id });
+  }
+  return warnings;
+}
+function verifyTimeline(d, cap, opts, positioned) {
+  const body = d.body;
+  const layoutOutcome = familyLayoutForVerify(d, positioned);
+  const layout = layoutOutcome.layout;
+  const warnings = [];
+  const hasContent = body.sections.length > 0 || body.title !== void 0 || body.accessibilityTitle !== void 0 || body.accessibilityDescription !== void 0;
+  if (!hasContent) return finalize([{ code: "EMPTY_DIAGRAM" }], layout, opts);
+  const overflow = (target, text) => {
+    const w = text !== void 0 ? labelOverflowWarning(target, text, cap) : null;
+    if (w) warnings.push(w);
+  };
+  overflow("title", body.title);
+  for (const s of body.sections) {
+    overflow(s.id, s.label);
+    for (const p of s.periods) {
+      overflow(p.id, p.label);
+      for (const e of p.events) overflow(e.id, e.text);
+    }
+  }
+  return finalize(dedupedConcat(dedupedConcat(warnings, layoutGeometryWarnings(layout, { nodeOverlaps: true, groupContainment: true })), layoutOutcome.warnings), layout, opts);
+}
+function verifySequence(d, cap, opts, positioned) {
+  const body = d.body;
+  const layoutOutcome = familyLayoutForVerify(d, positioned);
+  const layout = layoutOutcome.layout;
+  const warnings = [];
+  const hasOpaqueContent = body.statements.some(
+    (s) => s.kind === "opaque-block" && s.lines.some((l) => l.trim().length > 0)
+  );
+  const allMessages = sequenceMessages(body);
+  if (body.participants.length === 0 && allMessages.length === 0 && !hasOpaqueContent) {
+    return finalize([{ code: "EMPTY_DIAGRAM" }], layout, opts, false);
+  }
+  const ids = new Set(body.participants.map((p) => p.id));
+  allMessages.forEach((m, i) => {
+    if (!ids.has(m.from) || !ids.has(m.to)) {
+      warnings.push({
+        code: "EDGE_MISANCHORED",
+        edge: `msg#${i}:${m.from}->${m.to}`,
+        from: ids.has(m.from) ? m.from : void 0,
+        to: ids.has(m.to) ? m.to : void 0
+      });
+    }
+    const w = labelOverflowWarning(`msg#${i}:${m.from}->${m.to}`, m.text, cap);
+    if (w) warnings.push(w);
+  });
+  for (const p of body.participants) {
+    const w = labelOverflowWarning(p.id, p.label, cap);
+    if (w) warnings.push(w);
+  }
+  for (const statement of body.statements) if (statement.kind === "fragment") {
+    if (statement.fragment.label) {
+      const w = labelOverflowWarning(`fragment:${statement.fragment.fragmentKind}`, statement.fragment.label, cap);
+      if (w) warnings.push(w);
+    }
+    for (const [index, branch] of statement.fragment.branches.entries()) if (branch.label) {
+      const w = labelOverflowWarning(`fragment:${statement.fragment.fragmentKind}:branch#${index}`, branch.label, cap);
+      if (w) warnings.push(w);
+    }
+  }
+  const opaqueLines = body.statements.filter((s) => s.kind === "opaque-block").flatMap((s) => s.lines);
+  if (opaqueLines.length > 0) {
+    warnings.push({
+      code: "UNSUPPORTED_SYNTAX",
+      syntax: "sequence_opaque_segment",
+      message: "This sequence contains source-preserved constructs that are not represented in describe/facts or typed fragment operations. Inspect the source directly before relying on semantic read-back."
+    });
+    const plugin = getFamily(d.kind);
+    const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(opaqueLines.join("\n"));
+    const seen = /* @__PURE__ */ new Set();
+    for (const lbl of labels) {
+      const w = labelOverflowWarning(lbl.target, lbl.text, cap);
+      if (!w) continue;
+      const key = `${lbl.target}:${lbl.text}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      warnings.push(w);
+    }
+  }
+  const guardEmpty = body.participants.length === 0 && allMessages.length === 0;
+  return finalize(dedupedConcat(dedupedConcat(warnings, layoutGeometryWarnings(layout, { nodeOverlaps: true })), layoutOutcome.warnings), layout, opts, guardEmpty);
+}
+function isPositionedGraph(positioned) {
+  const candidate = positioned;
+  return Array.isArray(candidate.nodes) && Array.isArray(candidate.edges) && Array.isArray(candidate.groups);
+}
+function finalize(warnings, layout, opts, guardEmptyLayout = true) {
+  const suppress = new Set(opts.suppress ?? []);
+  const kept = warnings.filter((w) => !suppress.has(w.code));
+  const ok2 = !kept.some((w) => WARNING_SEVERITY[w.code] === "error");
+  if (guardEmptyLayout && !suppress.has("UNSUPPORTED_SYNTAX") && layout.nodes.length === 0 && layout.edges.length === 0 && layout.groups.length === 0 && layout.bounds.w === 0 && layout.bounds.h === 0 && !kept.some((w) => w.code === "EMPTY_DIAGRAM") && !kept.some((w) => w.code === "UNSUPPORTED_SYNTAX" && w.syntax === "empty_layout")) {
+    return {
+      ok: ok2,
+      warnings: [...kept, { code: "UNSUPPORTED_SYNTAX", syntax: "empty_layout", message: "The source carries content, but the local layout renders nothing (0x0 canvas with no nodes, edges, or groups)." }],
+      layout
+    };
+  }
+  return { ok: ok2, warnings: kept, layout };
+}
+function rectIntersection(a, b) {
+  const xo = Math.max(0, Math.min(a.x + a.width, b.x + b.width) - Math.max(a.x, b.x));
+  const yo = Math.max(0, Math.min(a.y + a.height, b.y + b.height) - Math.max(a.y, b.y));
+  return xo * yo;
+}
+function countSelfCrossings(points) {
+  if (points.length < 4) return 0;
+  let count = 0;
+  for (let i = 0; i < points.length - 1; i++)
+    for (let j = i + 2; j < points.length - 1; j++) {
+      if (i === 0 && j === points.length - 2) continue;
+      if (segInt(points[i], points[i + 1], points[j], points[j + 1])) count++;
+    }
+  return count;
+}
+function segInt(p1, p2, p3, p4) {
+  const d1 = cr(p4.x - p3.x, p4.y - p3.y, p1.x - p3.x, p1.y - p3.y);
+  const d2 = cr(p4.x - p3.x, p4.y - p3.y, p2.x - p3.x, p2.y - p3.y);
+  const d3 = cr(p2.x - p1.x, p2.y - p1.y, p3.x - p1.x, p3.y - p1.y);
+  const d4 = cr(p2.x - p1.x, p2.y - p1.y, p4.x - p1.x, p4.y - p1.y);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function cr(x1, y1, x2, y2) {
+  return x1 * y2 - x2 * y1;
+}
+function findSubgraphById(list, id) {
+  for (const sg of list) {
+    if (sg.id === id) return sg;
+    const c = findSubgraphById(sg.children, id);
+    if (c) return c;
+  }
+  return null;
+}
+
+// src/agent/apply.ts
+function verifySummary(v) {
+  return JSON.parse(JSON.stringify({ ok: v.ok, warnings: v.warnings }));
+}
+function snapshotOpArray(value) {
+  try {
+    if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return { ok: false };
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const length = descriptors.length?.value;
+    if (!Number.isSafeInteger(length) || length < 0) return { ok: false };
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key === "symbol" || key !== "length" && !/^(0|[1-9]\d*)$/.test(key))) return { ok: false };
+    const snapshot = [];
+    for (let index = 0; index < length; index++) {
+      const descriptor = descriptors[String(index)];
+      if (!descriptor || !("value" in descriptor) || descriptor.enumerable !== true) return { ok: false };
+      snapshot.push(descriptor.value);
+    }
+    return { ok: true, value: snapshot };
+  } catch {
+    return { ok: false };
+  }
+}
+function buildChecked(kind, ops, opts) {
+  const admitted = snapshotOpArray(ops);
+  if (!admitted.ok) {
+    return err({ code: "INVALID_OP", message: "`ops` must be an array of op objects", opIndex: -1 });
+  }
+  const checkedOps = admitted.value;
+  let d;
+  try {
+    d = createMermaid(kind, opts);
+  } catch (e) {
+    return err({ code: "INVALID_OP", message: e instanceof Error ? e.message : String(e), opIndex: -1 });
+  }
+  for (let i = 0; i < checkedOps.length; i++) {
+    const r = mutateChecked(d, checkedOps[i]);
+    if (!r.ok) {
+      let kindLabel;
+      try {
+        kindLabel = checkedOps[i]?.kind;
+      } catch {
+      }
+      return err({ ...r.error, opIndex: i, message: `op[${i}]${typeof kindLabel === "string" ? ` (${kindLabel})` : ""}: ${r.error.message}` });
+    }
+    d = r.value;
+  }
+  return ok(d);
+}
+function applyOps(input) {
+  let source;
+  let family;
+  let ops;
+  try {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+      return { ok: false, family: null, error: { code: "INVALID_OP", message: "applyOps input must be a plain object" } };
+    }
+    const prototype = Object.getPrototypeOf(input);
+    if (prototype !== Object.prototype && prototype !== null) {
+      return { ok: false, family: null, error: { code: "INVALID_OP", message: "applyOps input must be a plain object" } };
+    }
+    ;
+    ({ source, family, ops } = input);
+  } catch {
+    return { ok: false, family: null, error: { code: "INVALID_OP", message: "applyOps input must be a readable plain object" } };
+  }
+  const admittedOps = snapshotOpArray(ops);
+  if (!admittedOps.ok) {
+    return { ok: false, family: typeof family === "string" && hasOpSchema(family) ? family : null, error: { code: "INVALID_OP", message: "`ops` must be an array of op objects" } };
+  }
+  const checkedOps = admittedOps.value;
+  if (source !== void 0 && typeof source !== "string") {
+    return { ok: false, family: null, error: { code: "INVALID_OP", message: "`source` must be a string when provided" } };
+  }
+  if (family !== void 0 && typeof family !== "string") {
+    return { ok: false, family: null, error: { code: "INVALID_OP", message: "`family` must be a string when provided" } };
+  }
+  if (typeof source === "string" && typeof family === "string") {
+    return { ok: false, family: hasOpSchema(family) ? family : null, error: { code: "INVALID_OP", message: "applyOps accepts either `source` or `family`, not both" } };
+  }
+  let d;
+  if (typeof source === "string" && source.trim().length > 0) {
+    const parsed = parseRegisteredMermaid(source);
+    if (!parsed.ok) {
+      const primary = parsed.error[0];
+      return {
+        ok: false,
+        family: null,
+        error: {
+          code: primary?.code ?? "PARSE_ERROR",
+          message: parsed.error.map((e) => e.message).join("; ") || "could not parse source"
+        }
+      };
+    }
+    d = parsed.value;
+    if (!hasOpSchema(d.kind)) {
+      return { ok: false, family: d.kind, error: { code: "INVALID_OP", message: `family "${d.kind}" has no structured ops; edit it as source text` } };
+    }
+    if (checkedOps.length === 0) {
+      return { ok: false, family: d.kind, error: { code: "INVALID_OP", message: "`ops` must contain at least one op object" } };
+    }
+  } else if (typeof family === "string") {
+    if (!hasOpSchema(family)) {
+      return { ok: false, family: null, error: { code: "INVALID_OP", message: `unknown family "${family}"` } };
+    }
+    if (checkedOps.length === 0) {
+      return { ok: false, family, error: { code: "INVALID_OP", message: "`ops` must contain at least one op object" } };
+    }
+    const built = buildChecked(family, checkedOps);
+    if (!built.ok) {
+      const { opIndex, ...error } = built.error;
+      return { ok: false, family, opIndex: opIndex >= 0 ? opIndex : void 0, error };
+    }
+    return verifiedEnvelope(built.value);
+  } else {
+    return { ok: false, family: null, error: { code: "INVALID_OP", message: "applyOps requires either `source` (to edit) or `family` (to build)" } };
+  }
+  for (let i = 0; i < checkedOps.length; i++) {
+    const r = mutateChecked(d, checkedOps[i]);
+    if (!r.ok) return { ok: false, family: d.kind, opIndex: i, error: r.error };
+    d = r.value;
+  }
+  return verifiedEnvelope(d);
+}
+function verifiedEnvelope(diagram) {
+  const verification = verifyMermaid(diagram);
+  const summary = verifySummary(verification);
+  if (!verification.ok) {
+    return {
+      ok: false,
+      family: diagram.kind,
+      error: {
+        code: "VERIFY_FAILED",
+        message: "mutated diagram failed verify; source was not emitted",
+        details: summary.warnings
+      }
+    };
+  }
+  return {
+    ok: true,
+    family: diagram.kind,
+    source: serializeMermaid(diagram),
+    verify: summary
+  };
+}
+
+// src/agent/quality.ts
+var DEFAULT_BOUNDS = {
+  maxCrossingsRatio: 0.05,
+  minLabelLegibility: 0.85,
+  whitespaceBand: [0.05, 0.55],
+  minLabelEdgeProximity: 4,
+  minNodeSpacing: 8,
+  elementDensityBand: [0.02, 6],
+  minTextContrast: 4.5,
+  aspectBand: [0.2, 5]
+};
+var BOUND_PROVENANCE = {
+  edgeCrossings: {
+    basis: "evidence",
+    severity: "primary",
+    note: "Crossings are the single aesthetic with the strongest human-subject evidence (Purchase 1997/2002). Weight this violation highest."
+  },
+  labelLegibility: {
+    basis: "derived",
+    severity: "secondary",
+    note: "Labels that exceed node width are mechanically unreadable; the 7px/char model under-estimates fit under condensed fonts."
+  },
+  labelEdgeProximity: {
+    basis: "chosen",
+    severity: "secondary",
+    note: "Edge-labels overlapping nodes hurt readability, but the 4px floor is chosen, not validated against perception."
+  },
+  minimumNodeSpacing: {
+    basis: "chosen",
+    severity: "secondary",
+    note: "Box clearance catches cramped layouts, but the 8px floor is a conservative implementation threshold rather than a perceptual constant."
+  },
+  elementDensity: {
+    basis: "chosen",
+    severity: "secondary",
+    note: "Elements per canvas area distinguishes crowded marks from large boxes; the default band is a regression guard, not a universal aesthetic optimum."
+  },
+  minimumTextContrast: {
+    basis: "standard",
+    severity: "secondary",
+    note: "The 4.5:1 floor follows WCAG AA normal-text contrast. Callers should supply resolved surface colors when a style uses non-default fills."
+  },
+  whitespaceBalance: {
+    basis: "chosen",
+    severity: "secondary",
+    note: 'A node/canvas fill band is a rough proxy for "too sparse / too dense"; the literature gives weak support and the band is hand-set.'
+  },
+  aspectRatio: {
+    basis: "sanity",
+    severity: "sanity",
+    note: "Aspect ratio is a guardrail against absurd canvases, not an aesthetic; Purchase did not find it drives comprehension."
+  }
+};
+var CHAR_PX = 7;
+var EDGE_LABEL_BOX_PADDING = 8;
+var GEOM_EPS = 1e-9;
+function measureQuality(layout, options = {}) {
+  return {
+    edgeCrossings: countEdgeCrossings(layout.edges),
+    labelLegibility: measureLabelLegibility(layout.nodes),
+    whitespaceBalance: measureWhitespaceBalance(layout),
+    labelEdgeProximity: measureLabelEdgeProximity(layout),
+    minimumNodeSpacing: measureMinimumNodeSpacing(layout),
+    elementDensity: measureElementDensity(layout),
+    minimumTextContrast: measureMinimumTextContrast(options),
+    aspectRatio: layout.bounds.h > 0 ? layout.bounds.w / layout.bounds.h : Infinity,
+    nodeCount: layout.nodes.length,
+    edgeCount: layout.edges.length
+  };
+}
+function checkQuality(layout, bounds = {}, measurement = {}) {
+  const b = { ...DEFAULT_BOUNDS, ...bounds };
+  const m = measureQuality(layout, measurement);
+  const ranked = [];
+  const flag = (metric, message) => ranked.push({ metric, severity: BOUND_PROVENANCE[metric].severity, message });
+  const pairs = Math.max(1, m.edgeCount * (m.edgeCount - 1) / 2);
+  if (m.edgeCrossings / pairs > b.maxCrossingsRatio) {
+    flag("edgeCrossings", `edge crossings ${m.edgeCrossings}/${pairs} (${(m.edgeCrossings / pairs * 100).toFixed(1)}%) > cap ${(b.maxCrossingsRatio * 100).toFixed(1)}%`);
+  }
+  if (m.labelLegibility < b.minLabelLegibility) {
+    flag("labelLegibility", `label legibility ${(m.labelLegibility * 100).toFixed(0)}% < min ${(b.minLabelLegibility * 100).toFixed(0)}%`);
+  }
+  if (m.whitespaceBalance < b.whitespaceBand[0] || m.whitespaceBalance > b.whitespaceBand[1]) {
+    flag("whitespaceBalance", `whitespace balance ${(m.whitespaceBalance * 100).toFixed(1)}% outside band [${b.whitespaceBand[0] * 100}\u2013${b.whitespaceBand[1] * 100}]%`);
+  }
+  if (m.labelEdgeProximity < b.minLabelEdgeProximity) {
+    flag("labelEdgeProximity", `edge-label clearance ${m.labelEdgeProximity}px < min ${b.minLabelEdgeProximity}px`);
+  }
+  if (m.nodeCount >= 2 && m.minimumNodeSpacing < b.minNodeSpacing) {
+    flag("minimumNodeSpacing", `minimum node spacing ${m.minimumNodeSpacing}px < min ${b.minNodeSpacing}px`);
+  }
+  if (m.nodeCount > 0 && (m.elementDensity < b.elementDensityBand[0] || m.elementDensity > b.elementDensityBand[1])) {
+    flag("elementDensity", `element density ${m.elementDensity.toFixed(2)} outside band [${b.elementDensityBand[0]}\u2013${b.elementDensityBand[1]}] per 10,000px\xB2`);
+  }
+  if (m.minimumTextContrast === null) {
+    flag("minimumTextContrast", "minimum text contrast is unmeasurable because one or more requested paints could not be resolved");
+  } else if (m.minimumTextContrast < b.minTextContrast) {
+    flag("minimumTextContrast", `minimum text contrast ${m.minimumTextContrast.toFixed(2)}:1 < min ${b.minTextContrast}:1`);
+  }
+  if (m.aspectRatio < b.aspectBand[0] || m.aspectRatio > b.aspectBand[1]) {
+    flag("aspectRatio", `aspect ratio ${m.aspectRatio.toFixed(2)} outside band [${b.aspectBand[0]}\u2013${b.aspectBand[1]}]`);
+  }
+  const order = { primary: 0, secondary: 1, sanity: 2 };
+  ranked.sort((x, y) => order[x.severity] - order[y.severity]);
+  return { ok: ranked.length === 0, metrics: m, ranked };
+}
+function unionBoxes(items) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const item of items) {
+    minX = Math.min(minX, item.box.x);
+    minY = Math.min(minY, item.box.y);
+    maxX = Math.max(maxX, item.box.x + item.box.w);
+    maxY = Math.max(maxY, item.box.y + item.box.h);
+  }
+  return { x: minX, y: minY, w: maxX - minX, h: maxY - minY };
+}
+function buildSpacingTree(items) {
+  const box = unionBoxes(items);
+  if (items.length <= 8) return { box, items };
+  const axis = box.w >= box.h ? "x" : "y";
+  const sorted = [...items].sort((a, b) => (axis === "x" ? a.box.x + a.box.w / 2 - b.box.x - b.box.w / 2 : a.box.y + a.box.h / 2 - b.box.y - b.box.h / 2) || compareCodePointStrings(a.node.id, b.node.id));
+  const middle = Math.floor(sorted.length / 2);
+  return { box, left: buildSpacingTree(sorted.slice(0, middle)), right: buildSpacingTree(sorted.slice(middle)) };
+}
+function xyMarkIdentity(node) {
+  const match = node.id.match(/^(bar|line)#(\d+):pt#(\d+)$/);
+  if (!match) return void 0;
+  return { type: match[1], series: Number(match[2]), point: Number(match[3]) };
+}
+function radarMarkIdentity(node) {
+  const match = node.id.match(/^dot:(.+):(\d+)$/);
+  if (!match) return void 0;
+  return { curve: match[1], vertex: Number(match[2]) };
+}
+function spacingComparable(kind, a, b) {
+  if (kind === "xychart") {
+    const left = xyMarkIdentity(a);
+    const right = xyMarkIdentity(b);
+    if (!left || !right) return true;
+    if (left.type !== right.type) return left.point !== right.point;
+    return left.series === right.series || left.point !== right.point;
+  }
+  if (kind === "radar") {
+    const left = radarMarkIdentity(a);
+    const right = radarMarkIdentity(b);
+    if (!left || !right) return true;
+    const coincident = a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+    return left.curve === right.curve || left.vertex !== right.vertex || !coincident;
+  }
+  return true;
+}
+function nearestAcross(a, b, kind, current) {
+  if (rectDistance(a.box, b.box) >= current) return current;
+  if (a.items && b.items) {
+    for (const left of a.items) for (const right of b.items) {
+      if (!spacingComparable(kind, left.node, right.node)) continue;
+      current = Math.min(current, rectDistance(left.box, right.box));
+      if (current === 0) return 0;
+    }
+    return current;
+  }
+  const splitA = !b.items && a.items ? false : !a.items && (b.items || a.box.w * a.box.h >= b.box.w * b.box.h);
+  if (splitA) {
+    current = nearestAcross(a.left, b, kind, current);
+    return nearestAcross(a.right, b, kind, current);
+  }
+  current = nearestAcross(a, b.left, kind, current);
+  return nearestAcross(a, b.right, kind, current);
+}
+function nearestWithin(tree, kind, current = Infinity) {
+  if (tree.items) {
+    for (let i = 0; i < tree.items.length; i++) for (let j = i + 1; j < tree.items.length; j++) {
+      const a = tree.items[i], b = tree.items[j];
+      if (!spacingComparable(kind, a.node, b.node)) continue;
+      current = Math.min(current, rectDistance(a.box, b.box));
+      if (current === 0) return 0;
+    }
+    return current;
+  }
+  current = nearestWithin(tree.left, kind, current);
+  if (current === 0) return 0;
+  current = nearestWithin(tree.right, kind, current);
+  if (current === 0) return 0;
+  return nearestAcross(tree.left, tree.right, kind, current);
+}
+function measureMinimumNodeSpacing(layout) {
+  if (layout.nodes.length < 2) return Infinity;
+  const items = layout.nodes.map((node) => ({ node, box: nodeBox(node) }));
+  return nearestWithin(buildSpacingTree(items), layout.kind);
+}
+function measureElementDensity(layout) {
+  const area = layout.bounds.w * layout.bounds.h;
+  if (area <= 0) return Infinity;
+  return (layout.nodes.length + layout.edges.length) / (area / 1e4);
+}
+function cssRgba(value) {
+  return tryParseCssColor(value) ?? void 0;
+}
+function relativeLuminance(rgb) {
+  const channels = rgb.map((channel) => {
+    const value = channel / 255;
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  });
+  return channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722;
+}
+function contrastRatio(a, b) {
+  const [lighter, darker] = [relativeLuminance(a), relativeLuminance(b)].sort((x, y) => y - x);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function composite(foreground, background) {
+  const alpha = foreground[3];
+  return [0, 1, 2].map((index) => foreground[index] * alpha + background[index] * (1 - alpha));
+}
+function opaqueBackground(value) {
+  const parsed = cssRgba(value);
+  return parsed && parsed[3] === 1 ? [parsed[0], parsed[1], parsed[2]] : void 0;
+}
+function pairContrast(foregroundValue, backgroundValue, canvasValue) {
+  const foreground = cssRgba(foregroundValue);
+  const surface = cssRgba(backgroundValue);
+  const canvas = opaqueBackground(canvasValue);
+  if (!foreground || !surface || !canvas) return void 0;
+  const background = composite(surface, canvas);
+  return contrastRatio(composite(foreground, background), background);
+}
+function measureMinimumTextContrast(options) {
+  if (options.textPairs !== void 0) {
+    if (options.textPairs.length === 0) return null;
+    const canvas = options.background ?? "#FFFFFF";
+    let minimum2 = Infinity;
+    for (const pair of options.textPairs) {
+      const ratio = pairContrast(pair.foreground, pair.background, canvas);
+      if (ratio === void 0) return null;
+      minimum2 = Math.min(minimum2, ratio);
+    }
+    return minimum2;
+  }
+  const foreground = cssRgba(options.foreground ?? "#27272A");
+  const background = opaqueBackground(options.background ?? "#FFFFFF");
+  if (!foreground || !background) return null;
+  const requestedSurfaces = options.surfaces ?? [];
+  const parsedSurfaces = requestedSurfaces.map(cssRgba);
+  if (parsedSurfaces.some((surface) => surface === void 0)) return null;
+  let minimum = contrastRatio(composite(foreground, background), background);
+  for (const surface of parsedSurfaces) {
+    const resolved = composite(surface, background);
+    minimum = Math.min(minimum, contrastRatio(composite(foreground, resolved), resolved));
+  }
+  return minimum;
+}
+function countEdgeCrossings(edges) {
+  let count = 0;
+  for (let i = 0; i < edges.length; i++) {
+    for (let j = i + 1; j < edges.length; j++) {
+      const a = edges[i], b = edges[j];
+      const shared = a.from === b.from || a.from === b.to || a.to === b.from || a.to === b.to;
+      const ap = a.path, bp = b.path;
+      for (let ai = 0; ai < ap.length - 1; ai++) {
+        for (let bi = 0; bi < bp.length - 1; bi++) {
+          if (shared && (ai === 0 || ai === ap.length - 2) && (bi === 0 || bi === bp.length - 2)) continue;
+          if (segmentsCross(ap[ai], ap[ai + 1], bp[bi], bp[bi + 1])) count++;
+        }
+      }
+    }
+  }
+  return count;
+}
+function segmentsCross(p1, p2, p3, p4) {
+  const d = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+  const d1 = d(p3, p4, p1), d2 = d(p3, p4, p2);
+  const d3 = d(p1, p2, p3), d4 = d(p1, p2, p4);
+  return (d1 > 0 && d2 < 0 || d1 < 0 && d2 > 0) && (d3 > 0 && d4 < 0 || d3 < 0 && d4 > 0);
+}
+function measureLabelLegibility(nodes) {
+  if (nodes.length === 0) return 1;
+  let fits = 0;
+  for (const n of nodes) {
+    if (!n.label) {
+      fits++;
+      continue;
+    }
+    const renderedWidth = n.label.length * CHAR_PX;
+    if (renderedWidth <= n.w) fits++;
+  }
+  return fits / nodes.length;
+}
+function measureWhitespaceBalance(layout) {
+  const total = layout.bounds.w * layout.bounds.h;
+  if (total <= 0) return 0;
+  let filled = 0;
+  for (const n of layout.nodes) filled += n.w * n.h;
+  return Math.min(1, filled / total);
+}
+function nodeBox(n) {
+  return { x: n.x, y: n.y, w: n.w, h: n.h };
+}
+function edgeLabelBox(label) {
+  const metrics = measureMultilineText(label.text, FONT_SIZES.edgeLabel, FONT_WEIGHTS.edgeLabel);
+  const w = metrics.width + EDGE_LABEL_BOX_PADDING * 2;
+  const h = metrics.height + EDGE_LABEL_BOX_PADDING * 2;
+  return { x: label.x - w / 2, y: label.y - h / 2, w, h };
+}
+function rectDistance(a, b) {
+  const dx = Math.max(0, Math.max(a.x - (b.x + b.w), b.x - (a.x + a.w)));
+  const dy = Math.max(0, Math.max(a.y - (b.y + b.h), b.y - (a.y + a.h)));
+  return Math.hypot(dx, dy);
+}
+function pointInRect(p, r) {
+  return p[0] >= r.x && p[0] <= r.x + r.w && p[1] >= r.y && p[1] <= r.y + r.h;
+}
+function pointToRectDistance(p, r) {
+  const dx = Math.max(0, Math.max(r.x - p[0], p[0] - (r.x + r.w)));
+  const dy = Math.max(0, Math.max(r.y - p[1], p[1] - (r.y + r.h)));
+  return Math.hypot(dx, dy);
+}
+function pointToSegmentDistance(p, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const lenSq = dx * dx + dy * dy;
+  if (lenSq === 0) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  const t = Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / lenSq));
+  const projX = a[0] + t * dx;
+  const projY = a[1] + t * dy;
+  return Math.hypot(p[0] - projX, p[1] - projY);
+}
+function segmentsIntersectInclusive(a, b, c, d) {
+  const orient = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+  const onSegment = (p, q, r) => q[0] >= Math.min(p[0], r[0]) - GEOM_EPS && q[0] <= Math.max(p[0], r[0]) + GEOM_EPS && q[1] >= Math.min(p[1], r[1]) - GEOM_EPS && q[1] <= Math.max(p[1], r[1]) + GEOM_EPS;
+  const o1 = orient(a, b, c);
+  const o2 = orient(a, b, d);
+  const o3 = orient(c, d, a);
+  const o4 = orient(c, d, b);
+  if (Math.abs(o1) <= GEOM_EPS && onSegment(a, c, b)) return true;
+  if (Math.abs(o2) <= GEOM_EPS && onSegment(a, d, b)) return true;
+  if (Math.abs(o3) <= GEOM_EPS && onSegment(c, a, d)) return true;
+  if (Math.abs(o4) <= GEOM_EPS && onSegment(c, b, d)) return true;
+  return o1 > 0 !== o2 > 0 && o3 > 0 !== o4 > 0;
+}
+function segmentIntersectsRect(a, b, r) {
+  if (pointInRect(a, r) || pointInRect(b, r)) return true;
+  const topLeft = [r.x, r.y];
+  const topRight = [r.x + r.w, r.y];
+  const bottomRight = [r.x + r.w, r.y + r.h];
+  const bottomLeft = [r.x, r.y + r.h];
+  return segmentsIntersectInclusive(a, b, topLeft, topRight) || segmentsIntersectInclusive(a, b, topRight, bottomRight) || segmentsIntersectInclusive(a, b, bottomRight, bottomLeft) || segmentsIntersectInclusive(a, b, bottomLeft, topLeft);
+}
+function rectToSegmentDistance(r, a, b) {
+  if (segmentIntersectsRect(a, b, r)) return 0;
+  const corners = [
+    [r.x, r.y],
+    [r.x + r.w, r.y],
+    [r.x + r.w, r.y + r.h],
+    [r.x, r.y + r.h]
+  ];
+  return Math.min(
+    pointToRectDistance(a, r),
+    pointToRectDistance(b, r),
+    ...corners.map((c) => pointToSegmentDistance(c, a, b))
+  );
+}
+function measureLabelEdgeProximity(layout) {
+  let min = Infinity;
+  const labels = layout.edges.filter((e) => e.label !== void 0).map((e) => ({ edge: e, box: edgeLabelBox(e.label) }));
+  for (const { edge, box } of labels) {
+    for (const n of layout.nodes) {
+      if (n.id === edge.from || n.id === edge.to) continue;
+      const d = rectDistance(box, nodeBox(n));
+      if (d < min) min = d;
+    }
+  }
+  for (let i = 0; i < labels.length; i++) {
+    for (let j = i + 1; j < labels.length; j++) {
+      const d = rectDistance(labels[i].box, labels[j].box);
+      if (d < min) min = d;
+    }
+  }
+  for (const { edge, box } of labels) {
+    for (const other of layout.edges) {
+      if (other === edge) continue;
+      for (let i = 0; i < other.path.length - 1; i++) {
+        const d = rectToSegmentDistance(box, other.path[i], other.path[i + 1]);
+        if (d < min) min = d;
+      }
+    }
+  }
+  return min;
+}
+
+// src/agent/certificates.ts
+function layoutCertificateProof(cert) {
+  if ("elementId" in cert) return regionContainmentProof(cert);
+  return edgeRouteProof(cert);
+}
+function edgeRouteProof(cert) {
+  if ("family" in cert) return familyEdgeRouteProof(cert);
+  return flowchartEdgeRouteProof(cert);
+}
+function flowchartEdgeRouteProof(cert) {
+  switch (cert.invariant) {
+    case "straight":
+    case "explained-detour":
+    case "bundle":
+    case "outer-feedback":
+    case "feedback-detour":
+    case "self-loop":
+    case "container-attach":
+    case "unverified-shape":
+      return "edge-route";
+    default:
+      return assertNever(cert);
+  }
+}
+function familyEdgeRouteProof(cert) {
+  switch (cert.family) {
+    case "class":
+    case "er":
+      return familyBoxRouteProof(cert.invariant);
+    case "architecture":
+      return architectureRouteProof(cert.invariant);
+    case "sequence":
+      return sequenceRouteProof(cert.invariant);
+    default:
+      return assertNever(cert);
+  }
+}
+function familyBoxRouteProof(invariant) {
+  switch (invariant) {
+    case "orthogonal-box":
+    case "unverified-family-route":
+      return "edge-route";
+    default:
+      return assertNever(invariant);
+  }
+}
+function architectureRouteProof(invariant) {
+  switch (invariant) {
+    case "side-anchored":
+    case "unverified-family-route":
+      return "edge-route";
+    default:
+      return assertNever(invariant);
+  }
+}
+function sequenceRouteProof(invariant) {
+  switch (invariant) {
+    case "lifeline-message":
+    case "self-message":
+    case "unverified-family-route":
+      return "edge-route";
+    default:
+      return assertNever(invariant);
+  }
+}
+function regionContainmentProof(cert) {
+  switch (cert.family) {
+    case "timeline":
+    case "xychart":
+    case "pie":
+    case "quadrant":
+    case "gantt":
+      return regionInvariantProof(cert.invariant);
+    default:
+      return assertNever(cert.family);
+  }
+}
+function regionInvariantProof(invariant) {
+  switch (invariant) {
+    case "timeline-interval":
+    case "plot-contained":
+    case "legend-contained":
+    case "section-contained":
+    case "unverified-family-layout":
+      return "region-containment";
+    default:
+      return assertNever(invariant);
+  }
+}
+function assertNever(value) {
+  throw new Error(`Unhandled layout certificate variant: ${JSON.stringify(value)}`);
+}
+
+// src/agent/family-registration.ts
+var WITNESS_RENDER_OPTIONS = Object.freeze({
+  security: "strict",
+  embedFontImport: false
+});
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function parsedExample(descriptor) {
+  const parsed = parseRegisteredMermaid(descriptor.example);
+  if (!parsed.ok) {
+    throw new Error(parsed.error.map((error) => `${error.code}: ${error.message}`).join("; "));
+  }
+  if (parsed.value.kind !== descriptor.id) {
+    throw new Error(`canonical example routed to "${parsed.value.kind}" instead of "${descriptor.id}"`);
+  }
+  return parsed.value;
+}
+function parsedWitness(descriptor) {
+  const parsed = parsedExample(descriptor);
+  return {
+    kind: parsed.kind,
+    ..."descriptorIdentity" in parsed ? { descriptorIdentity: parsed.descriptorIdentity } : {},
+    meta: parsed.meta,
+    body: parsed.body,
+    canonicalSource: parsed.canonicalSource
+  };
+}
+function serializationWitness(descriptor) {
+  const serialized = serializeMermaid(parsedExample(descriptor));
+  const reparsed = parseRegisteredMermaid(serialized);
+  if (!reparsed.ok) {
+    throw new Error(`serialized canonical example did not reparse: ${reparsed.error.map((error) => error.message).join("; ")}`);
+  }
+  if (reparsed.value.kind !== descriptor.id) {
+    throw new Error(`serializer changed family identity to "${reparsed.value.kind}"`);
+  }
+  const serializedAgain = serializeMermaid(reparsed.value);
+  if (serializedAgain !== serialized) {
+    throw new Error("serializer is not byte-stable after parse \u2192 serialize \u2192 reparse");
+  }
+  return { serialized, reparsedKind: reparsed.value.kind, canonicalSource: reparsed.value.canonicalSource };
+}
+function layoutWitness(descriptor) {
+  const parsed = parsedExample(descriptor);
+  const artifact = positionFamilyArtifact(parsed, {
+    output: "layout",
+    renderOptions: WITNESS_RENDER_OPTIONS
+  });
+  if (!artifact) throw new Error(`canonical example has no public positioned-layout projection`);
+  const positionedBounds = [artifact.positioned.width, artifact.positioned.height];
+  const projectedBounds = [artifact.rendered.bounds.w, artifact.rendered.bounds.h];
+  if ([...positionedBounds, ...projectedBounds].some((value) => !Number.isFinite(value) || value <= 0)) {
+    throw new Error("canonical example layout and projected bounds must be finite and positive");
+  }
+  if (artifact.rendered.nodes.length + artifact.rendered.edges.length + artifact.rendered.groups.length === 0) {
+    throw new Error("canonical example layout must expose at least one semantic node, edge, or group");
+  }
+  return {
+    layout: artifact.rendered,
+    receiptDigest: renderContractDigest(receiptOf(artifact.request))
+  };
+}
+function visitScene(nodes, callback) {
+  for (const node of nodes) {
+    callback(node);
+    if (node.kind === "group") visitScene(node.children.map((child) => child.node), callback);
+  }
+}
+function sceneWitness(descriptor) {
+  const request = resolveRenderRequestForExecution(
+    descriptor.example,
+    WITNESS_RENDER_OPTIONS,
+    "svg"
+  );
+  const layout = positionResolvedFamily(descriptor.id, request);
+  const scene = lowerPositionedFamilyScene(request, layout);
+  const observed = /* @__PURE__ */ new Set();
+  visitScene(scene.parts, (node) => {
+    for (const primitive of sceneNodePrimitives(node)) observed.add(`${node.role}\0${primitive}`);
+  });
+  const missing = descriptor.scenePrimitiveEvidence.filter((cell) => cell.applicability === "applicable").filter((cell) => !observed.has(`${cell.role}\0${cell.primitive}`)).map((cell) => `${cell.role}/${cell.primitive}`);
+  if (missing.length > 0) {
+    throw new Error(`canonical example did not witness declared positive Scene cells: ${missing.join(", ")}`);
+  }
+  return {
+    sceneDigest: renderContractDigest(scene),
+    cells: [...observed].sort(),
+    receiptDigest: renderContractDigest(receiptOf(request))
+  };
+}
+function svgWitness(descriptor) {
+  const svg = executeGraphicalRequest(
+    descriptor.example,
+    WITNESS_RENDER_OPTIONS,
+    "svg"
+  );
+  const png = renderPortablePngGraphicalProjection(
+    descriptor.example,
+    WITNESS_RENDER_OPTIONS
+  );
+  return {
+    svg: svg.svg,
+    svgReceiptDigest: renderContractDigest(svg.receipt),
+    pngSvg: png.svg,
+    pngReceiptDigest: renderContractDigest(png.receipt),
+    rasterBackground: png.rasterBackground,
+    rasterDimensions: png.rasterDimensions
+  };
+}
+function terminalWitness(descriptor) {
+  const outputs = [];
+  for (const useAscii of [true, false]) {
+    for (const colorMode of RESOLVED_TERMINAL_COLOR_MODES) {
+      const encoding = useAscii ? "ascii" : "unicode";
+      let rendered;
+      try {
+        rendered = renderMermaidASCIIWithReceipt(descriptor.example, {
+          ...WITNESS_RENDER_OPTIONS,
+          useAscii,
+          colorMode
+        });
+      } catch (error) {
+        throw new Error(`${encoding}/${colorMode} terminal witness failed: ${reasonOf(error)}`);
+      }
+      outputs.push({
+        encoding,
+        colorMode,
+        textDigest: renderContractDigest(rendered.text),
+        receiptDigest: renderContractDigest(rendered.receipt)
+      });
+    }
+  }
+  return { outputs };
+}
+function verifyWitness(descriptor) {
+  const verified = verifyMermaid(descriptor.example, { renderOptions: WITNESS_RENDER_OPTIONS });
+  if (!verified.ok) {
+    const diagnostics = verified.warnings.map((warning2) => warning2.code === "RENDER_FAILED" ? `${warning2.code}: ${warning2.reason}` : warning2.code);
+    throw new Error(`canonical example failed verification: ${diagnostics.join(", ")}`);
+  }
+  return verified;
+}
+function capabilityWitness(descriptor, capability) {
+  switch (capability) {
+    case "detection": {
+      const parsed = parsedExample(descriptor);
+      return { family: parsed.kind, canonicalSource: parsed.canonicalSource };
+    }
+    case "source-preservation": {
+      const parsed = parsedExample(descriptor);
+      return {
+        family: parsed.kind,
+        canonicalSource: parsed.canonicalSource,
+        roundtrip: serializationWitness(descriptor)
+      };
+    }
+    case "parse":
+      return parsedWitness(descriptor);
+    case "serialize":
+      return serializationWitness(descriptor);
+    case "mutation":
+      throw new Error("external structured mutation is not an executable native capability");
+    case "verify":
+      return verifyWitness(descriptor);
+    case "layout":
+      return layoutWitness(descriptor);
+    case "scene":
+      return sceneWitness(descriptor);
+    case "svg":
+      return svgWitness(descriptor);
+    case "terminal":
+      return terminalWitness(descriptor);
+  }
+}
+function runCapabilityConformance(descriptor, capability) {
+  const declaredState = descriptor.capabilityEvidence.find((claim) => claim.capability === capability).state;
+  if (declaredState !== "native") {
+    return Object.freeze({
+      capability,
+      declaredState,
+      status: "unverified-extension",
+      diagnostic: `Descriptor declares "${declaredState}"; no executable native claim was made.`
+    });
+  }
+  const witnessId = `family-example@${FAMILY_CONFORMANCE_VERSION}/${descriptor.id}/${capability}`;
+  try {
+    const first = renderContractDigest(capabilityWitness(descriptor, capability));
+    const second = renderContractDigest(capabilityWitness(descriptor, capability));
+    if (first !== second) {
+      throw new Error(`canonical example was nondeterministic (${first} != ${second})`);
+    }
+    return Object.freeze({ capability, declaredState, status: "passed", witnessId });
+  } catch (error) {
+    return Object.freeze({
+      capability,
+      declaredState,
+      status: "failed",
+      diagnostic: reasonOf(error)
+    });
+  }
+}
+function runFamilyConformance(descriptor) {
+  const capabilities = Object.freeze(FAMILY_CAPABILITY_COLUMNS.map((capability) => runCapabilityConformance(descriptor, capability)));
+  return Object.freeze({
+    version: FAMILY_CONFORMANCE_VERSION,
+    familyId: descriptor.id,
+    example: descriptor.example,
+    passed: capabilities.every((result) => result.declaredState !== "native" || result.status === "passed"),
+    capabilities
+  });
+}
+var FamilyConformanceError = class extends Error {
+  report;
+  constructor(report) {
+    const failures = report.capabilities.filter((result) => result.status === "failed").map((result) => `${result.capability}: ${result.diagnostic}`);
+    super(`Family "${report.familyId}" failed executable registration conformance: ${failures.join("; ")}`);
+    this.name = "FamilyConformanceError";
+    this.report = report;
+  }
+};
+function registerFamily(descriptor) {
+  const staged = stageFamilyCandidateForConformance(
+    descriptor,
+    assertFamilyScopedRenderOptionDeclaration
+  );
+  try {
+    const report = runFamilyConformance(staged.descriptor);
+    if (!report.passed) throw new FamilyConformanceError(report);
+    return staged.commit(report);
+  } catch (error) {
+    staged.rollback();
+    throw error;
+  }
+}
+
+// src/agent/analyze.ts
+function analyzeMermaid(d) {
+  return {
+    kind: d.kind,
+    feedbackEdges: feedbackEdges(d),
+    actions: collectActionRecords(d),
+    ...d.body.kind === "gantt" ? ganttAnalysis(d) : {}
+  };
+}
+function analyzeMermaidSource(source) {
+  const parsed = parseRegisteredMermaid(source);
+  return parsed.ok ? ok(analyzeMermaid(parsed.value)) : err(parsed.error);
+}
+function feedbackEdges(d) {
+  let graph = null;
+  if (d.body.kind === "flowchart") graph = d.body.graph;
+  else if (d.body.kind === "state") graph = stateBodyToGraph(d.body);
+  else if (d.kind === "flowchart" && d.body.kind === "opaque") {
+    try {
+      graph = parseMermaid(d.canonicalSource);
+    } catch {
+      graph = null;
+    }
+  }
+  if (!graph) return [];
+  const classes = classifyRoutes(graph);
+  return graph.edges.flatMap((edge, edgeIndex) => classes[edgeIndex] === "feedback" ? [{ edgeIndex, from: edge.source, to: edge.target, label: edge.label, routeClass: "feedback" }] : []);
+}
+function ganttAnalysis(d) {
+  if (d.body.kind !== "gantt") return {};
+  try {
+    const normalized = normalizeMermaidSource(d.canonicalSource);
+    const model = applyGanttFrontmatterConfig(parseGanttModel(normalized.lines), normalized.frontmatter);
+    const schedule = resolveGanttSchedule(model);
+    return schedule.analysis ? { gantt: {
+      criticalPathTaskIds: [...schedule.analysis.criticalPathTaskIds],
+      slackByTaskId: { ...schedule.analysis.slackByTaskId },
+      projectStart: schedule.analysis.projectStart,
+      projectEnd: schedule.analysis.projectEnd,
+      entryTaskIds: [...schedule.analysis.entryTaskIds],
+      sinkTaskIds: [...schedule.analysis.sinkTaskIds]
+    } } : {};
+  } catch {
+    return {};
+  }
+}
+function collectActionRecords(d) {
+  const source = d.body.kind === "opaque" || d.body.kind === "extension" || d.body.kind === "preserved" ? d.body.source : d.canonicalSource;
+  const records = [];
+  if (d.kind === "flowchart") records.push(...collectFlowchartActions(source));
+  if (d.kind === "class") records.push(...collectClassActions(source));
+  if (d.kind === "sequence") records.push(...collectSequenceActions(source));
+  if (d.body.kind === "gantt") records.push(...collectGanttActions(d));
+  const seen = /* @__PURE__ */ new Map();
+  return records.map((record) => {
+    const key = `${record.family}:${record.target}`;
+    const n = seen.get(key) ?? 0;
+    seen.set(key, n + 1);
+    return { id: `action:${record.family}:${record.target}:${n}`, regionId: `node:${record.target}`, ...record };
+  });
+}
+function collectClassActions(source) {
+  const out = [];
+  let inClassBody = false;
+  for (const sourceLine of actionSourceLines(source)) {
+    for (const text of expandInlineNamespaceStatement(sourceLine.text)) {
+      if (inClassBody) {
+        if (text.trim() === "}") inClassBody = false;
+        continue;
+      }
+      const declaration = parseClassDeclaration(text);
+      if (declaration?.opensBody) {
+        inClassBody = true;
+        continue;
+      }
+      const embedded = parseClassInteraction(text);
+      if (embedded) {
+        out.push(actionRecord("class", embedded.id, "href", embedded.href, sourceLine.line));
+        continue;
+      }
+      const callback = text.match(/^(callback)\s+(`[^`]+`(?:~[^~]+~)?|[\w$]+(?:~[^~]+~)?)\s+(.+)$/i);
+      if (callback) {
+        const ref2 = parseClassReference(callback[2]);
+        if (ref2) out.push(actionRecord("class", ref2.id, "callback", callback[3], sourceLine.line));
+        continue;
+      }
+      const match = text.match(/^(click|link)\s+(`[^`]+`(?:~[^~]+~)?|[\w$]+(?:~[^~]+~)?)\s+(.+)$/i);
+      if (!match) continue;
+      const ref = parseClassReference(match[2]);
+      if (!ref) continue;
+      const rest = match[3].trim();
+      const explicit = rest.match(/^(href|call|callback)\s+(.+)$/i);
+      const kind = explicit?.[1]?.toLowerCase();
+      if (kind === "call" || kind === "callback") {
+        out.push(actionRecord("class", ref.id, kind, explicit[2], sourceLine.line));
+      } else {
+        const raw = kind === "href" ? explicit[2] : rest;
+        out.push(actionRecord(
+          "class",
+          ref.id,
+          match[1].toLowerCase() === "link" || looksLikeHref(raw) ? "href" : "callback",
+          raw,
+          sourceLine.line
+        ));
+      }
+    }
+  }
+  return out;
+}
+function collectFlowchartActions(source) {
+  const out = [];
+  for (const sourceLine of actionSourceLines(source, true)) {
+    for (const text of splitFlowchartStatements(sourceLine.text)) {
+      if (!text || text.startsWith("%%")) continue;
+      let m = text.match(/^href\s+(\S+)\s+(.+)$/i);
+      if (m) {
+        out.push(actionRecord("flowchart", m[1], "href", m[2], sourceLine.line));
+        continue;
+      }
+      m = text.match(/^click\s+(\S+)\s+(.+)$/i);
+      if (!m) continue;
+      const target = m[1];
+      const rest = m[2].trim();
+      const explicit = rest.match(/^(href|call)\s+(.+)$/i);
+      const callback = rest.match(/^callback(?:\s+(.+))?$/i);
+      if (explicit?.[1]?.toLowerCase() === "href") out.push(actionRecord("flowchart", target, "href", explicit[2], sourceLine.line));
+      else if (explicit?.[1]?.toLowerCase() === "call") out.push(actionRecord("flowchart", target, "call", explicit[2], sourceLine.line));
+      else if (callback) out.push(actionRecord("flowchart", target, "callback", callback[1] ?? "", sourceLine.line));
+      else out.push(actionRecord("flowchart", target, looksLikeHref(rest) ? "href" : "callback", rest, sourceLine.line));
+    }
+  }
+  return out;
+}
+function actionSourceLines(source, maskMarkdownStrings = false) {
+  const out = [];
+  const lines = source.split(/\r?\n/);
+  let inAccessibilityBlock = false;
+  let inMarkdownString = false;
+  for (let index = 0; index < lines.length; index++) {
+    const preserveActionText = maskMarkdownStrings && !inMarkdownString && splitFlowchartStatements(lines[index]).some((statement) => /^(?:click|href)\s+/i.test(statement.trim()));
+    const masked = maskMarkdownStrings && !preserveActionText ? maskMarkdownStringContent(lines[index], inMarkdownString) : { text: lines[index], open: false };
+    inMarkdownString = masked.open;
+    const text = masked.text.trim();
+    if (inAccessibilityBlock) {
+      if (text.includes("}")) inAccessibilityBlock = false;
+      continue;
+    }
+    const block = text.match(/^accDescr\s*:?\s*\{\s*(.*)$/i);
+    if (block) {
+      if (!block[1].includes("}")) inAccessibilityBlock = true;
+      continue;
+    }
+    if (/^acc(?:Title|Descr)(?:\s*:|\s+)/i.test(text)) continue;
+    out.push({ text, line: index + 1 });
+  }
+  return out;
+}
+function collectSequenceActions(source) {
+  return actionSourceLines(source).flatMap((sourceLine) => {
+    const parsed = parseActorLinks(sourceLine.text);
+    return parsed ? Object.values(parsed.links).map(
+      (href) => actionRecord("sequence", parsed.actorId, "href", href, sourceLine.line)
+    ) : [];
+  });
+}
+function maskMarkdownStringContent(line, initiallyOpen) {
+  let open = initiallyOpen;
+  let escaped = false;
+  let text = "";
+  for (const character of line) {
+    if (escaped) {
+      text += open ? " " : character;
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      text += open ? " " : character;
+      escaped = true;
+      continue;
+    }
+    if (character === "`") {
+      text += " ";
+      open = !open;
+      continue;
+    }
+    text += open ? " " : character;
+  }
+  return { text, open };
+}
+function collectGanttActions(d) {
+  if (d.body.kind !== "gantt") return [];
+  try {
+    const model = parseGanttModel(toMermaidLines(d.canonicalSource));
+    return model.clicks.map((click) => actionRecord("gantt", click.taskId, click.action, click.rest, click.line));
+  } catch {
+    return [];
+  }
+}
+function actionRecord(family, target, action, raw, line) {
+  const href = action === "href" ? firstActionToken(raw) : void 0;
+  const unsafe = href !== void 0 && !isSafeHref(href);
+  return {
+    family,
+    target,
+    action,
+    raw,
+    line,
+    href,
+    executable: false,
+    security: action === "href" ? unsafe ? "unsafe" : "safe" : "source-only",
+    message: action === "href" ? unsafe ? "Unsafe href is source-only and must be stripped by strict renderers." : "Href is an action record; non-SVG renderers keep it as source-only metadata." : "Callbacks/calls are recorded for analysis but are never executed."
+  };
+}
+function firstActionToken(raw) {
+  const trimmed = raw.trim();
+  const quote = trimmed[0];
+  if (quote === '"' || quote === "'") {
+    let token = "";
+    for (let index = 1; index < trimmed.length; index++) {
+      const character = trimmed[index];
+      if (character === quote) return token;
+      if (character === "\\" && index + 1 < trimmed.length) {
+        const next = trimmed[index + 1];
+        if (next === quote || next === "\\") {
+          token += next;
+          index++;
+          continue;
+        }
+      }
+      token += character;
+    }
+    return token;
+  }
+  return trimmed.split(/\s+/)[0] ?? "";
+}
+function isSafeHref(href) {
+  return isSafeActionHref(href);
+}
+function looksLikeHref(raw) {
+  const trimmed = raw.trim();
+  const token = firstActionToken(raw);
+  const quoted = trimmed[0] === '"' || trimmed[0] === "'";
+  return quoted || isSafeHref(token) && /^(?:https?:|mailto:|#|\/|\.\/|\.\.)/i.test(token);
+}
+
+// src/ascii/meta.ts
+import { decodeXML } from "entities";
+var ASCII_ROUTE_PARITY_CONTRACT = {
+  version: 1,
+  routeIntent: "shared-route-classes",
+  svgSource: "route-contract classifyRoutes() + certificates",
+  asciiSource: "grid router seeded with classifyRoutes() routeClass metadata, longest-path layering, and direct-lane-first routing",
+  degradationWarnings: ["ASCII_RENDER_FAILED", "ASCII_EDGE_REGION_UNMAPPED"]
+};
+function renderMermaidASCIIWithMeta(input, opts = {}) {
+  const source = prepareRenderInput(input).source;
+  try {
+    const projection = [];
+    const ascii = renderMermaidASCII(input, {
+      ...opts,
+      onProjectionDiagnostic: (diagnostic) => {
+        projection.push(diagnostic);
+        opts.onProjectionDiagnostic?.(diagnostic);
+      }
+    });
+    const regions = addSemanticContainerRegions(ascii, source, deriveRegions(ascii, source));
+    const projectionWarnings = projection.map((diagnostic) => ({
+      code: diagnostic.code,
+      severity: "degraded",
+      message: diagnostic.message
+    }));
+    return { ascii, regions, actions: actionRecords(source), warnings: [...deriveWarnings(source, regions), ...projectionWarnings], routeParity: ASCII_ROUTE_PARITY_CONTRACT };
+  } catch (error) {
+    if (error instanceof ParsedDiagramFamilyMismatchError) throw error;
+    return { ascii: "", regions: [], actions: [], warnings: [{ code: "ASCII_RENDER_FAILED", severity: "degraded", message: "ASCII/Unicode renderer failed; no route parity evidence is available." }], routeParity: ASCII_ROUTE_PARITY_CONTRACT };
+  }
+}
+function actionRecords(source) {
+  const parsed = parseRegisteredMermaid(source);
+  return parsed.ok ? collectActionRecords(parsed.value).map(sanitizeTerminalAction) : [];
+}
+function sanitizeTerminalAction(action) {
+  const safe = (value) => value === void 0 ? void 0 : sanitizeTerminalText(value);
+  return {
+    ...action,
+    id: safe(action.id),
+    regionId: safe(action.regionId),
+    target: safe(action.target),
+    raw: safe(action.raw),
+    href: safe(action.href),
+    message: safe(action.message)
+  };
+}
+function deriveWarnings(source, regions) {
+  const parsed = parseRegisteredMermaid(source);
+  if (!parsed.ok) return [];
+  if (parsed.value.body.kind !== "flowchart" && parsed.value.body.kind !== "state") return [];
+  const edgeRegions = regions.filter((r) => r.kind === "edge").length;
+  const edgeCount = parsed.value.body.kind === "flowchart" ? parsed.value.body.graph.edges.length : parsed.value.body.transitions.length;
+  if (edgeCount > 0 && edgeRegions === 0) {
+    return [{
+      code: "ASCII_EDGE_REGION_UNMAPPED",
+      severity: "degraded",
+      message: "ASCII route drawing follows the explicit route-intent parity mapping, but per-edge cell spans are not instrumented yet."
+    }];
+  }
+  return [];
+}
+function addCandidate(out, id, label, sourceLine, kind = "node") {
+  const normalized = label?.trim();
+  if (!normalized) return;
+  out.push({ id, label: normalized, sourceLine, kind });
+}
+function addCandidateWithFallback(out, id, label, sourceLine, kind = "node") {
+  addCandidate(out, id, label, sourceLine, kind);
+  if (label !== id) addCandidate(out, id, id, sourceLine, kind);
+}
+function deriveRegions(ascii, source) {
+  const candidates = candidatesForDiagram(source);
+  if (candidates.length === 0) return [];
+  const lines = ascii.split("\n");
+  const sorted = [...candidates].sort((a, b) => visualWidth(b.label) - visualWidth(a.label));
+  const used = /* @__PURE__ */ new Set();
+  const occupied = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const c of sorted) {
+    const candidateKey = `${c.kind ?? "node"}\0${c.id}`;
+    if (used.has(candidateKey)) continue;
+    const match = matchProjectedLabel(lines, c.label, occupied, (c.kind ?? "node") === "node");
+    if (!match) continue;
+    out.push({
+      kind: c.kind ?? "node",
+      id: c.id,
+      sourceLine: c.sourceLine,
+      canvasRow: match.row,
+      canvasColStart: match.colStart,
+      canvasColEnd: match.colEnd,
+      ...match.rowSpan > 1 ? { rowSpan: match.rowSpan } : {},
+      projectedText: projectedLabelText(c.label),
+      authoredTextCells: match.authoredTextCells
+    });
+    used.add(candidateKey);
+  }
+  out.sort((a, b) => a.canvasRow - b.canvasRow || a.canvasColStart - b.canvasColStart);
+  return out;
+}
+function overlapsOccupied(occupied, occurrence) {
+  return (occupied.get(occurrence.row) ?? []).some(([start, end]) => occurrence.colStart < end && occurrence.colEnd > start);
+}
+function occurrencesOf(lines, text, occupied) {
+  const out = [];
+  if (!text) return out;
+  for (let row = 0; row < lines.length; row++) {
+    const line = lines[row];
+    for (let start = line.indexOf(text); start >= 0; start = line.indexOf(text, start + Math.max(1, text.length))) {
+      const end = start + text.length;
+      const occurrence = {
+        row,
+        start,
+        end,
+        colStart: visualWidth(line.slice(0, start)),
+        colEnd: visualWidth(line.slice(0, end)),
+        text
+      };
+      if (!overlapsOccupied(occupied, occurrence)) out.push(occurrence);
+    }
+  }
+  return out;
+}
+var NODE_TEXT_BOUNDARY_GLYPHS = /* @__PURE__ */ new Set(["|", "\u2502", "\u2551", "\u251C", "\u2524", "\u253C", "\u256B", "\u256A", "+"]);
+function nodeTextBandScore(lines, occurrence) {
+  const line = lines[occurrence.row] ?? "";
+  const before = graphemes(line.slice(0, occurrence.start).trimEnd()).at(-1);
+  const after = graphemes(line.slice(occurrence.end).trimStart())[0];
+  return before !== void 0 && after !== void 0 && NODE_TEXT_BOUNDARY_GLYPHS.has(before) && NODE_TEXT_BOUNDARY_GLYPHS.has(after) ? 1 : 0;
+}
+function preferredOccurrences(lines, occurrences, preferNodeTextBand) {
+  return [...occurrences].sort((a, b) => (preferNodeTextBand ? nodeTextBandScore(lines, b) - nodeTextBandScore(lines, a) : 0) || a.row - b.row || a.colStart - b.colStart);
+}
+function projectedLabelText(label) {
+  return sanitizeTerminalText(decodeXML(plainTextFromInlineFormatting(normalizeBrTags(label))), true).replace(/^[`]|[`]$/g, "").trim();
+}
+function claimOccurrences(occurrences, occupied) {
+  for (const occurrence of occurrences) {
+    const spans = occupied.get(occurrence.row) ?? [];
+    spans.push([occurrence.colStart, occurrence.colEnd]);
+    occupied.set(occurrence.row, spans);
+  }
+  const firstRow = Math.min(...occurrences.map((occurrence) => occurrence.row));
+  const lastRow = Math.max(...occurrences.map((occurrence) => occurrence.row));
+  const authoredTextCells = occurrences.flatMap((occurrence) => {
+    let column = occurrence.colStart;
+    return graphemes(occurrence.text).map((glyph) => {
+      const cell = { row: occurrence.row, column, glyph };
+      column += visualWidth(glyph);
+      return cell;
+    });
+  });
+  return {
+    row: firstRow,
+    colStart: Math.min(...occurrences.map((occurrence) => occurrence.colStart)),
+    colEnd: Math.max(...occurrences.map((occurrence) => occurrence.colEnd)),
+    rowSpan: lastRow - firstRow + 1,
+    authoredTextCells
+  };
+}
+function matchProjectedLabel(lines, label, occupied, preferNodeTextBand) {
+  const projected = projectedLabelText(label);
+  for (const text of /* @__PURE__ */ new Set([label, projected])) {
+    const occurrence = preferredOccurrences(lines, occurrencesOf(lines, text, occupied), preferNodeTextBand)[0];
+    if (occurrence) return claimOccurrences([occurrence], occupied);
+  }
+  const tokens = projected.split(/\s+/).filter(Boolean);
+  if (tokens.length < 2) return void 0;
+  for (const first of preferredOccurrences(lines, occurrencesOf(lines, tokens[0], occupied), preferNodeTextBand)) {
+    const matches = [first];
+    let previous = first;
+    let rowStart = first.colStart;
+    let rowEnd = first.colEnd;
+    let complete = true;
+    for (const token of tokens.slice(1)) {
+      const next = preferredOccurrences(lines, occurrencesOf(lines, token, occupied), preferNodeTextBand).find((candidate) => candidate.row === previous.row && candidate.colStart >= previous.colEnd && candidate.colStart - previous.colEnd <= 3 || candidate.row === previous.row + 1 && candidate.colStart < rowEnd && candidate.colEnd > rowStart);
+      if (!next) {
+        complete = false;
+        break;
+      }
+      matches.push(next);
+      if (next.row === previous.row) {
+        rowStart = Math.min(rowStart, next.colStart);
+        rowEnd = Math.max(rowEnd, next.colEnd);
+      } else {
+        rowStart = next.colStart;
+        rowEnd = next.colEnd;
+      }
+      previous = next;
+    }
+    if (complete) return claimOccurrences(matches, occupied);
+  }
+  return void 0;
+}
+function semanticContainers(source) {
+  const parsed = parseRegisteredMermaid(source);
+  if (!parsed.ok) return [];
+  const body = parsed.value.body;
+  if (body.kind === "state") {
+    const out = [];
+    const visit2 = (states) => states.flatMap((state) => {
+      let members = [];
+      if (state.regions) {
+        state.regions.forEach((region, index) => {
+          const regionMembers = visit2(region.states);
+          out.push({ id: `${state.id}__r${index + 1}`, kind: "cluster", members: regionMembers });
+          members.push(...regionMembers);
+        });
+      } else if (state.states) {
+        members = visit2(state.states);
+      }
+      if (state.states || state.regions) out.push({ id: state.id, kind: "cluster", members });
+      return [state.id, ...members];
+    });
+    visit2(body.states);
+    return out;
+  }
+  if (body.kind === "sequence") {
+    let index = 0;
+    return (body.statements ?? []).flatMap((statement) => statement.kind === "fragment" ? [{ id: `block#${index++}:${statement.fragment.fragmentKind}`, kind: "compartment", members: [] }] : []);
+  }
+  if (body.kind === "class") {
+    return (body.namespaces ?? []).map((namespace) => ({
+      id: namespace.name,
+      kind: "cluster",
+      members: body.classes.filter((cls) => cls.namespace === namespace.name).map((cls) => cls.id)
+    }));
+  }
+  if (body.kind === "er") return (body.groups ?? []).map((group) => ({
+    id: group.id,
+    kind: "cluster",
+    members: [
+      ...body.entities.filter((entity) => entity.groupId === group.id).map((entity) => entity.id),
+      ...(body.groups ?? []).filter((child) => child.parentId === group.id).map((child) => child.id)
+    ]
+  }));
+  if (body.kind === "xychart") return [{ id: "plot", kind: "plot", members: [] }];
+  if (body.kind === "radar") return Array.from({ length: body.ticks }, (_, index) => ({
+    id: `ring:${index}`,
+    kind: "ring",
+    members: [],
+    geometry: { kind: "ring", index, count: body.ticks }
+  }));
+  if (body.kind === "quadrant") return Array.from({ length: 4 }, (_, index) => ({
+    id: `quadrant#${index + 1}`,
+    kind: "compartment",
+    members: [],
+    geometry: { kind: "quadrant", index: index + 1 }
+  }));
+  if (body.kind === "gantt") return body.sections.map((section, index) => ({
+    id: `section#${index}`,
+    kind: "band",
+    members: section.tasks.map((task) => task.taskId ?? task.id)
+  }));
+  return [];
+}
+function addSemanticContainerRegions(ascii, source, regions) {
+  const lines = ascii.split("\n");
+  const canvasEnd = Math.max(1, ...lines.map(visualWidth));
+  const canvasRows = Math.max(1, lines.length);
+  const result = [...regions];
+  for (const container of semanticContainers(source)) {
+    if (result.some((region) => region.id === container.id && region.kind === container.kind)) continue;
+    const members = result.filter((region) => container.members.includes(region.id));
+    if (container.geometry?.kind === "quadrant") {
+      const left = container.geometry.index === 2 || container.geometry.index === 3;
+      const top = container.geometry.index === 1 || container.geometry.index === 2;
+      const halfCol = Math.floor(canvasEnd / 2);
+      const halfRow = Math.floor(canvasRows / 2);
+      result.push({
+        id: container.id,
+        kind: container.kind,
+        canvasRow: top ? 0 : halfRow,
+        canvasColStart: left ? 0 : halfCol,
+        canvasColEnd: left ? Math.max(1, halfCol) : canvasEnd,
+        rowSpan: Math.max(1, top ? halfRow : canvasRows - halfRow)
+      });
+      continue;
+    }
+    if (container.geometry?.kind === "ring") {
+      const maxInset = Math.max(0, Math.floor(Math.min(canvasEnd, canvasRows) / 2) - 1);
+      const inset = container.geometry.count <= 1 ? 0 : Math.round((container.geometry.count - 1 - container.geometry.index) * maxInset / container.geometry.count);
+      result.push({
+        id: container.id,
+        kind: container.kind,
+        canvasRow: inset,
+        canvasColStart: inset,
+        canvasColEnd: Math.max(inset + 1, canvasEnd - inset),
+        rowSpan: Math.max(1, canvasRows - inset * 2)
+      });
+      continue;
+    }
+    const firstRow = members.length > 0 ? Math.min(...members.map((region) => region.canvasRow)) : 0;
+    const lastRow = members.length > 0 ? Math.max(...members.map((region) => region.canvasRow + (region.rowSpan ?? 1))) : Math.max(1, lines.length);
+    result.push({
+      id: container.id,
+      kind: container.kind,
+      canvasRow: firstRow,
+      canvasColStart: members.length > 0 ? Math.min(...members.map((region) => region.canvasColStart)) : 0,
+      canvasColEnd: members.length > 0 ? Math.max(...members.map((region) => region.canvasColEnd)) : canvasEnd,
+      rowSpan: Math.max(1, lastRow - firstRow)
+    });
+  }
+  result.sort((a, b) => a.canvasRow - b.canvasRow || a.canvasColStart - b.canvasColStart || compareCodePointStrings(a.id, b.id));
+  return result;
+}
+function orderGraphNodesForTerminal(graph, nodes) {
+  try {
+    const config = {
+      useAscii: false,
+      paddingX: 5,
+      paddingY: 5,
+      boxBorderPadding: 1,
+      graphDirection: graph.direction === "LR" || graph.direction === "RL" ? "LR" : "TD"
+    };
+    const projected = convertToAsciiGraph(graph, config);
+    createMapping(projected);
+    const position = new Map(projected.nodes.flatMap((node) => node.drawingCoord ? [[node.name, node.drawingCoord]] : []));
+    const bottomToTop = graph.direction === "BT";
+    nodes.sort((a, b) => {
+      const pa = position.get(a.id);
+      const pb = position.get(b.id);
+      if (!pa || !pb) return pa ? -1 : pb ? 1 : 0;
+      const row = bottomToTop ? pb.y - pa.y : pa.y - pb.y;
+      return row || pa.x - pb.x;
+    });
+  } catch {
+  }
+}
+function orderClassesForTerminal(body) {
+  const classes = [...body.classes];
+  const parents = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const relation of body.relations) {
+    const hierarchical = relation.kind === "inheritance" || relation.kind === "realization";
+    const parent = hierarchical && relation.markerAt === "to" ? relation.to : relation.from;
+    const child = hierarchical && relation.markerAt === "to" ? relation.from : relation.to;
+    if (!parents.has(child)) parents.set(child, /* @__PURE__ */ new Set());
+    parents.get(child).add(parent);
+    if (!children.has(parent)) children.set(parent, /* @__PURE__ */ new Set());
+    children.get(parent).add(child);
+  }
+  const level = /* @__PURE__ */ new Map();
+  const queue = classes.filter((cls) => !parents.has(cls.id) || parents.get(cls.id).size === 0).map((cls) => cls.id);
+  for (const id of queue) level.set(id, 0);
+  const cap = Math.max(0, classes.length - 1);
+  for (let cursor = 0; cursor < queue.length; cursor++) {
+    const id = queue[cursor];
+    for (const child of children.get(id) ?? []) {
+      const next = (level.get(id) ?? 0) + 1;
+      if (next > cap) continue;
+      if (!level.has(child) || level.get(child) < next) {
+        level.set(child, next);
+        queue.push(child);
+      }
+    }
+  }
+  for (const cls of classes) if (!level.has(cls.id)) level.set(cls.id, 0);
+  const authoredIndex = new Map(classes.map((cls, index) => [cls.id, index]));
+  return classes.sort((a, b) => level.get(a.id) - level.get(b.id) || authoredIndex.get(a.id) - authoredIndex.get(b.id));
+}
+function legacyClassBodyForCandidates(source) {
+  try {
+    const legacy = parseClassDiagram(toMermaidLines(source));
+    const namespaces = [];
+    const namespaceByClass = /* @__PURE__ */ new Map();
+    const visitNamespaces = (items, parent = "") => {
+      for (const namespace of items) {
+        const path = parent ? `${parent}.${namespace.name}` : namespace.name;
+        namespaces.push(namespace.label === void 0 ? { name: path } : { name: path, label: namespace.label });
+        for (const id of namespace.classIds) if (!namespaceByClass.has(id)) namespaceByClass.set(id, path);
+        visitNamespaces(namespace.children, path);
+      }
+    };
+    visitNamespaces(legacy.namespaces);
+    return {
+      kind: "class",
+      classes: legacy.classes.map((cls) => ({
+        id: cls.id,
+        label: cls.label,
+        generic: cls.generic,
+        members: [],
+        ...namespaceByClass.has(cls.id) ? { namespace: namespaceByClass.get(cls.id) } : {}
+      })),
+      relations: legacy.relationships.map((relation) => ({
+        from: relation.from,
+        to: relation.to,
+        kind: relation.type,
+        markerAt: relation.markerAt
+      })),
+      notes: [],
+      ...namespaces.length > 0 ? { namespaces } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function classCandidates(body) {
+  const classes = body.classes.some((cls, index, all) => all.findIndex((other) => (other.label || other.id) === (cls.label || cls.id)) !== index) ? orderClassesForTerminal(body) : body.classes;
+  const namespaces = body.namespaces ?? [];
+  const namespaceLabel = (name, label) => label ?? name.split(".").at(-1) ?? name;
+  const collidingNamespaces = new Set(namespaces.filter((namespace) => body.classes.some((cls) => (cls.namespace === namespace.name || cls.namespace?.startsWith(`${namespace.name}.`)) && (cls.label || cls.id) === namespaceLabel(namespace.name, namespace.label))).map((namespace) => namespace.name));
+  const out = [];
+  for (const namespace of namespaces) {
+    if (collidingNamespaces.has(namespace.name)) {
+      addCandidateWithFallback(out, namespace.name, namespaceLabel(namespace.name, namespace.label), void 0, "cluster");
+    }
+  }
+  out.push(...classes.flatMap((c) => {
+    const out2 = [];
+    addCandidateWithFallback(out2, c.id, c.label || c.id);
+    return out2;
+  }));
+  for (const namespace of namespaces) {
+    if (!collidingNamespaces.has(namespace.name)) {
+      addCandidateWithFallback(out, namespace.name, namespaceLabel(namespace.name, namespace.label), void 0, "cluster");
+    }
+  }
+  return out;
+}
+function candidatesForDiagram(source) {
+  const r = parseRegisteredMermaid(source);
+  if (!r.ok) return [];
+  const d = r.value;
+  let graphBody;
+  let nodeSourceLine;
+  let groupSourceLine;
+  if (d.body.kind === "flowchart") {
+    graphBody = d.body.graph;
+    nodeSourceLine = (id) => d.source.nodes.get(id)?.line;
+    groupSourceLine = (id) => d.source.groups.get(id)?.line;
+  } else if (d.kind === "flowchart") {
+    try {
+      graphBody = parseMermaid(d.canonicalSource);
+    } catch {
+      graphBody = void 0;
+    }
+  }
+  if (graphBody) {
+    const out = [];
+    const nodes = [...graphBody.nodes.values()];
+    const labels = nodes.map((node) => node.label && node.label.length > 0 ? node.label : node.id);
+    if (new Set(labels).size !== labels.length) {
+      orderGraphNodesForTerminal(graphBody, nodes);
+    }
+    const collidingGroups = /* @__PURE__ */ new Set();
+    const descendantIds = (group) => [
+      ...group.nodeIds,
+      ...group.children.flatMap(descendantIds)
+    ];
+    const groupCollidesWithMember = (group) => {
+      const groupLabel = group.label || group.id;
+      return descendantIds(group).some((id) => {
+        const node = graphBody.nodes.get(id);
+        return (node?.label || node?.id) === groupLabel;
+      });
+    };
+    const addGroups = (groups, colliding) => {
+      for (const group of groups) {
+        if (groupCollidesWithMember(group)) collidingGroups.add(group.id);
+        if (collidingGroups.has(group.id) === colliding) {
+          addCandidateWithFallback(out, group.id, group.label || group.id, groupSourceLine?.(group.id), "subgraph");
+        }
+        addGroups(group.children, colliding);
+      }
+    };
+    addGroups(graphBody.subgraphs, true);
+    for (const n of nodes) addCandidateWithFallback(out, n.id, n.label && n.label.length > 0 ? n.label : n.id, nodeSourceLine?.(n.id));
+    const visit2 = (groups) => {
+      for (const g of groups) {
+        if (!collidingGroups.has(g.id)) addCandidateWithFallback(out, g.id, g.label || g.id, groupSourceLine?.(g.id), "subgraph");
+        visit2(g.children);
+      }
+    };
+    visit2(graphBody.subgraphs);
+    return out;
+  }
+  if (d.body.kind === "state") {
+    const out = [];
+    const topLevel = [...d.body.states];
+    const labels = topLevel.map((state) => state.label ?? state.id);
+    if (new Set(labels).size !== labels.length) orderGraphNodesForTerminal(stateBodyToGraph(d.body), topLevel);
+    const visit2 = (states) => {
+      for (const s of states) {
+        const nested = s.states ?? s.regions?.flatMap((region) => region.states) ?? [];
+        addCandidateWithFallback(out, s.id, s.label ?? s.id, void 0, nested.length > 0 ? "cluster" : "node");
+        if (nested.length > 0) visit2(nested);
+      }
+    };
+    visit2(topLevel);
+    return out;
+  }
+  if (d.body.kind === "sequence") {
+    const out = d.body.participants.flatMap((p) => {
+      const out2 = [];
+      addCandidateWithFallback(out2, p.id, p.label || p.id);
+      return out2;
+    });
+    let blockIndex = 0;
+    for (const statement of d.body.statements ?? []) {
+      if (statement.kind !== "fragment") continue;
+      addCandidateWithFallback(
+        out,
+        `block#${blockIndex++}:${statement.fragment.fragmentKind}`,
+        statement.fragment.label ?? statement.fragment.fragmentKind,
+        void 0,
+        "compartment"
+      );
+    }
+    return out;
+  }
+  if (d.body.kind === "class") return classCandidates(d.body);
+  if (d.kind === "class") {
+    const classBody = legacyClassBodyForCandidates(d.canonicalSource);
+    if (classBody) return classCandidates(classBody);
+  }
+  if (d.body.kind === "er") {
+    const out = d.body.entities.map((e) => ({ id: e.id, label: e.id }));
+    for (const group of d.body.groups ?? []) {
+      addCandidateWithFallback(out, group.id, group.label || group.id, void 0, "cluster");
+    }
+    return out;
+  }
+  if (d.body.kind === "timeline") {
+    const out = [];
+    for (const s of d.body.sections) {
+      addCandidate(out, s.id, s.label, void 0, "band");
+      for (const p of s.periods) addCandidate(out, p.id, p.label);
+    }
+    return out;
+  }
+  if (d.body.kind === "journey") {
+    const out = [];
+    addCandidate(out, "title", d.body.title);
+    for (const s of d.body.sections) {
+      addCandidate(out, s.id, s.label, void 0, "band");
+      for (const t of s.tasks) addCandidate(out, t.id, t.text);
+    }
+    return out;
+  }
+  if (d.body.kind === "architecture") {
+    const out = [];
+    for (const g of d.body.groups) addCandidateWithFallback(out, g.id, g.label || g.id, void 0, "cluster");
+    for (const s of d.body.services) addCandidateWithFallback(out, s.id, s.label || s.id);
+    return out;
+  }
+  if (d.body.kind === "xychart") {
+    const out = [];
+    addCandidate(out, "title", d.body.title);
+    addCandidate(out, "x-axis", d.body.xAxis?.name);
+    addCandidate(out, "y-axis", d.body.yAxis?.name);
+    d.body.xAxis?.categories?.forEach((label, index) => addCandidate(out, `x-category-${index}`, label));
+    for (const s of d.body.series) addCandidate(out, s.id, s.name);
+    return out;
+  }
+  if (d.body.kind === "pie") {
+    const out = [];
+    addCandidate(out, "title", d.body.title);
+    for (const s of d.body.slices) addCandidate(out, s.id, s.label);
+    return out;
+  }
+  if (d.body.kind === "quadrant") {
+    const out = [];
+    addCandidate(out, "title", d.body.title);
+    addCandidate(out, "x-axis-near", d.body.xAxis?.near);
+    addCandidate(out, "x-axis-far", d.body.xAxis?.far);
+    addCandidate(out, "y-axis-near", d.body.yAxis?.near);
+    addCandidate(out, "y-axis-far", d.body.yAxis?.far);
+    d.body.quadrants.forEach((label, index) => addCandidate(out, `quadrant-label#${index + 1}`, label, void 0, "label"));
+    d.body.points.forEach((p, index) => addCandidate(out, `point-${index}`, p.label));
+    return out;
+  }
+  if (d.body.kind === "gantt") {
+    const out = [];
+    for (let index = 0; index < d.body.sections.length; index++) {
+      const s = d.body.sections[index];
+      addCandidate(out, `section-label#${index}`, s.label, void 0, "label");
+      for (const t of s.tasks) addCandidate(out, t.taskId ?? t.id, t.label);
+    }
+    return out;
+  }
+  if (d.body.kind === "gitgraph") {
+    const out = [];
+    for (const branch of d.body.branches) addCandidate(out, `branch:${branch.name}`, branch.name, void 0, "lane");
+    for (const commit of d.body.commits) addCandidateWithFallback(out, commit.id, commit.message || commit.id);
+    return out;
+  }
+  if (d.body.kind === "mindmap") {
+    const out = [];
+    const visit2 = (node) => {
+      addCandidateWithFallback(out, node.id, node.label || node.id);
+      for (const child of node.children) visit2(child);
+    };
+    visit2(d.body.root);
+    return out;
+  }
+  if (d.body.kind === "radar") {
+    const out = [];
+    for (const axis of d.body.axes) addCandidateWithFallback(out, axis.id, axis.label || axis.id);
+    for (const curve of d.body.curves) addCandidateWithFallback(out, curve.id, curve.label || curve.id);
+    return out;
+  }
+  return [];
+}
+
+// src/agent/facts.ts
+function describeMermaidFacts(d) {
+  const out = [];
+  add(out, `family ${d.kind}`);
+  if (d.meta.accessibility.title) add(out, `accessibility title ${clean(d.meta.accessibility.title)}`);
+  if (d.meta.accessibility.descr) add(out, `accessibility descr ${clean(d.meta.accessibility.descr)}`);
+  switch (d.body.kind) {
+    case "flowchart": {
+      const g = d.body.graph;
+      add(out, `direction ${g.direction}`);
+      for (const n of g.nodes.values()) {
+        add(out, `node ${clean(n.id)} : ${clean(n.label || n.id)}`);
+        add(out, `node ${clean(n.id)} shape ${clean(n.shape)}`);
+      }
+      const visitGroups = (items, parent) => {
+        for (const group of items) {
+          add(out, `group ${clean(group.id)} : ${clean(group.label || group.id)}`);
+          if (parent) add(out, `group ${clean(group.id)} parent ${clean(parent)}`);
+          if (group.direction) add(out, `group ${clean(group.id)} direction ${group.direction}`);
+          for (const nodeId of group.nodeIds) add(out, `group ${clean(group.id)} contains ${clean(nodeId)}`);
+          visitGroups(group.children, group.id);
+        }
+      };
+      visitGroups(g.subgraphs);
+      g.edges.forEach((e, i) => {
+        const base = `edge ${clean(e.source)} -> ${clean(e.target)}`;
+        add(out, e.label ? `${base} : ${clean(e.label)}` : base);
+        add(out, `edge#${i} ${clean(e.source)} -> ${clean(e.target)}${e.label ? ` : ${clean(e.label)}` : ""}`);
+        if (e.style !== "solid") add(out, `${base} style ${e.style}`);
+      });
+      break;
+    }
+    case "state":
+      factsState(out, d.body);
+      break;
+    case "sequence":
+      factsSequence(out, d.body);
+      break;
+    case "timeline":
+      factsTimeline(out, d.body);
+      break;
+    case "class":
+      factsClass(out, d.body);
+      break;
+    case "er":
+      factsEr(out, d.body);
+      break;
+    case "journey":
+      factsJourney(out, d.body);
+      break;
+    case "architecture":
+      factsArchitecture(out, d.body);
+      break;
+    case "xychart":
+      factsXyChart(out, d.body);
+      break;
+    case "pie":
+      factsPie(out, d.body);
+      break;
+    case "quadrant":
+      factsQuadrant(out, d.body);
+      break;
+    case "gantt":
+      factsGantt(out, d.body);
+      break;
+    case "mindmap":
+      factsMindmap(out, d.body);
+      break;
+    case "gitgraph":
+      factsGitGraph(out, d.body);
+      break;
+    case "radar": {
+      if (d.body.title !== void 0) add(out, `title ${clean(d.body.title)}`);
+      d.body.axes.forEach((a, i) => add(out, `axis#${i} ${clean(a.id)} : ${clean(a.label)}`));
+      d.body.curves.forEach((c, i) => add(out, `curve#${i} ${clean(c.id)} : ${clean(c.label)} {${c.values.join(",")}}`));
+      add(out, `scale ${d.body.min}..${d.body.max ?? "auto"} ticks ${d.body.ticks} graticule ${d.body.graticule}`);
+      break;
+    }
+    case "opaque": {
+      add(out, `opaque ${d.body.family}`);
+      const plugin = getFamily(d.kind);
+      const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+      labels.forEach((label, i) => add(out, `label#${i} ${clean(label.target || "")} : ${clean(label.text)}`));
+      break;
+    }
+    case "extension": {
+      const plugin = getFamily(d.kind);
+      const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+      labels.forEach((label, i) => add(out, `label#${i} ${clean(label.target || "")} : ${clean(label.text)}`));
+      break;
+    }
+    case "preserved":
+      add(out, `preserved ${d.body.preservation.upstreamFamilyId ?? d.body.preservation.header}`);
+      break;
+    default: {
+      const _never = d.body;
+      void _never;
+    }
+  }
+  return Array.from(new Set(out)).sort();
+}
+function describeMermaidFactsSource(source) {
+  const parsed = parseRegisteredMermaid(source);
+  return parsed.ok ? ok(describeMermaidFacts(parsed.value)) : err(parsed.error);
+}
+function checkMermaid(d, spec) {
+  const facts = describeMermaidFacts(d);
+  const have = new Set(facts);
+  const required = specRequired(spec);
+  const forbidden = specForbidden(spec);
+  const missing = required.filter((f) => !have.has(f));
+  let unexpected = forbidden.filter((f) => have.has(f));
+  if (isObjectSpec(spec) && spec.exact) {
+    const allowed = new Set(required);
+    unexpected = [...unexpected, ...facts.filter((f) => !allowed.has(f))];
+  }
+  unexpected = Array.from(new Set(unexpected)).sort();
+  return { ok: missing.length === 0 && unexpected.length === 0, missing, unexpected, facts };
+}
+function checkMermaidSource(source, spec) {
+  const parsed = parseRegisteredMermaid(source);
+  return parsed.ok ? ok(checkMermaid(parsed.value, spec)) : err(parsed.error);
+}
+function factsState(out, body) {
+  if (body.direction) add(out, `direction ${body.direction}`);
+  const visit2 = (states, transitions, path) => {
+    for (const s of states) {
+      add(out, `state ${clean(s.id)}`);
+      if (s.label) add(out, `state ${clean(s.id)} : ${clean(s.label)}`);
+      if (s.stereotype) add(out, `state ${clean(s.id)} stereotype ${clean(s.stereotype)}`);
+      if (path) add(out, `state ${clean(s.id)} parent ${clean(path)}`);
+      if (s.states !== void 0 || s.regions !== void 0) {
+        add(out, `composite ${clean(s.id)}`);
+        if (s.direction) add(out, `state ${clean(s.id)} direction ${s.direction}`);
+        if (s.regions) s.regions.forEach((region, index) => {
+          add(out, `state ${clean(s.id)} region ${index}`);
+          visit2(region.states, region.transitions, s.id);
+        });
+        else visit2(s.states ?? [], s.transitions ?? [], s.id);
+      }
+      if (s.className) add(out, `state ${clean(s.id)} class ${clean(s.className)}`);
+      if (s.style) add(out, `state ${clean(s.id)} styled`);
+    }
+    for (const t of transitions) add(out, edgeFact(t.from, t.to, t.label));
+  };
+  visit2(body.states, body.transitions);
+  for (const [index, note] of (body.notes ?? []).entries()) {
+    add(out, `note#${index} ${note.side} of ${clean(note.target)} : ${clean(note.text)}`);
+  }
+}
+function factsSequence(out, body) {
+  body.participants.forEach((p, i) => {
+    add(out, `${p.kind} ${clean(p.id)} : ${clean(p.label || p.id)}`);
+    add(out, `participant#${i} ${clean(p.id)} : ${clean(p.label || p.id)}`);
+  });
+  sequenceMessageContexts(body).forEach((context, i) => {
+    const m = context.message;
+    add(out, `message ${clean(m.from)} -> ${clean(m.to)} : ${clean(m.text)}`);
+    add(out, `message#${i} ${context.scope === "top-level" ? "top-level" : `fragment#${context.fragmentIndex} branch#${context.branchIndex}`} ${clean(m.from)} -> ${clean(m.to)} : ${clean(m.text)}`);
+    if (m.style !== "sync") add(out, `message#${i} style ${m.style}`);
+  });
+  const fragments = body.statements.filter((statement) => statement.kind === "fragment");
+  fragments.forEach((statement, index) => {
+    if (statement.kind !== "fragment") return;
+    add(out, `fragment#${index} ${statement.fragment.fragmentKind}`);
+    statement.fragment.branches.forEach((branch, branchIndex) => {
+      const label = branch.label ?? (branchIndex === 0 ? statement.fragment.label : void 0);
+      add(out, `fragment#${index} branch#${branchIndex}${label ? ` : ${clean(label)}` : ""}`);
+    });
+  });
+}
+function factsTimeline(out, body) {
+  if (body.title) add(out, `title ${clean(body.title)}`);
+  body.sections.forEach((s, si) => {
+    if (s.label) add(out, `section ${clean(s.label)}`);
+    s.periods.forEach((p, pi) => {
+      add(out, `period ${clean(p.label)}`);
+      if (s.label) add(out, `period ${clean(p.label)} section ${clean(s.label)}`);
+      p.events.forEach((e, ei) => {
+        add(out, `event ${clean(p.label)} : ${clean(e.text)}`);
+        add(out, `event#${si}.${pi}.${ei} ${clean(p.label)} : ${clean(e.text)}`);
+      });
+    });
+  });
+}
+function factsClass(out, body) {
+  if (body.title) add(out, `title ${clean(body.title)}`);
+  for (const ns of body.namespaces ?? []) {
+    add(out, `namespace ${clean(ns.name)}${ns.label ? ` : ${clean(ns.label)}` : ""}`);
+  }
+  for (const c of body.classes) {
+    add(out, `class ${clean(c.id)}`);
+    if (c.generic) add(out, `class ${clean(c.id)} generic ${clean(c.generic)}`);
+    if (c.label) add(out, `class ${clean(c.id)} : ${clean(c.label)}`);
+    if (c.namespace) add(out, `class ${clean(c.id)} in namespace ${clean(c.namespace)}`);
+    for (const member of c.members) add(out, `member ${clean(c.id)} ${clean(member)}`);
+  }
+  body.relations.forEach((r, i) => {
+    const cards = `${r.fromCardinality ? ` ${clean(r.fromCardinality)}` : ""}${r.toCardinality ? ` ${clean(r.toCardinality)}` : ""}`;
+    add(out, `relation ${clean(r.from)} ${r.kind} ${clean(r.to)}${r.label ? ` : ${clean(r.label)}` : ""}`);
+    add(out, `relation#${i} ${clean(r.from)} ${r.kind} ${clean(r.to)}${cards}${r.label ? ` : ${clean(r.label)}` : ""}`);
+  });
+  body.notes.forEach((n, i) => add(out, `note#${i}${n.for ? ` ${clean(n.for)}` : ""} : ${clean(n.text)}`));
+}
+function factsEr(out, body) {
+  if (body.direction) add(out, `direction ${body.direction}`);
+  for (const group of body.groups ?? []) add(out, `er group ${clean(group.id)} label ${clean(group.label)}${group.parentId ? ` parent ${clean(group.parentId)}` : ""}${group.direction ? ` direction ${group.direction}` : ""}`);
+  for (const e of body.entities) {
+    add(out, `entity ${clean(e.id)}${e.label ? ` label ${clean(e.label)}` : ""}${e.groupId ? ` group ${clean(e.groupId)}` : ""}`);
+    if (e.className) add(out, `entity ${clean(e.id)} class ${clean(e.className)}`);
+    if (e.style) add(out, `entity ${clean(e.id)} styled`);
+    for (const attr of e.attributes) add(out, `attribute ${clean(e.id)} ${clean(attr.text)}`);
+  }
+  body.relations.forEach((r, i) => {
+    const line = `relation ${clean(r.from)} ${r.leftCard} ${r.dashed ? ".." : "--"} ${r.rightCard} ${clean(r.to)}${r.label ? ` : ${clean(r.label)}` : ""}`;
+    add(out, line);
+    add(out, `relation#${i} ${line.slice("relation ".length)}`);
+  });
+}
+function factsJourney(out, body) {
+  if (body.title) add(out, `title ${clean(body.title)}`);
+  body.sections.forEach((s, si) => {
+    if (s.label) add(out, `section ${clean(s.label)}`);
+    s.tasks.forEach((t, ti) => {
+      const actors = t.actors.length ? ` actors ${t.actors.map(clean).join(", ")}` : "";
+      add(out, `journey task ${clean(t.text)} score ${num2(t.score)}${actors}`);
+      add(out, `journey task#${si}.${ti} ${clean(t.text)} score ${num2(t.score)}${actors}`);
+      if (s.label) add(out, `journey task ${clean(t.text)} section ${clean(s.label)}`);
+    });
+  });
+  const tasks = body.sections.flatMap((s) => s.tasks);
+  add(out, `journey sections ${body.sections.length}`);
+  add(out, `journey tasks ${tasks.length}`);
+  const participation = /* @__PURE__ */ new Map();
+  for (const t of tasks) for (const a of t.actors) participation.set(a, (participation.get(a) ?? 0) + 1);
+  add(out, `journey actors ${participation.size}`);
+  if (tasks.length > 0) {
+    const scores = tasks.map((t) => t.score);
+    const min = Math.min(...scores);
+    const max = Math.max(...scores);
+    const average = Math.round(scores.reduce((sum, score) => sum + score, 0) / scores.length * 100) / 100;
+    add(out, `journey score range ${min}..${max}`);
+    add(out, `journey average score ${num2(average)}`);
+    for (const t of tasks) {
+      if (t.score === min) add(out, `journey lowest task ${clean(t.text)} score ${num2(t.score)}`);
+      if (t.score === max) add(out, `journey highest task ${clean(t.text)} score ${num2(t.score)}`);
+    }
+  }
+  for (const [actor, count] of participation) add(out, `journey actor ${clean(actor)} tasks ${count}`);
+}
+function factsArchitecture(out, body) {
+  if (body.title) add(out, `title ${clean(body.title)}`);
+  if (body.accessibilityTitle) add(out, `accessibility title ${clean(body.accessibilityTitle)}`);
+  if (body.accessibilityDescription) add(out, `accessibility description ${clean(body.accessibilityDescription)}`);
+  for (const g of body.groups) {
+    add(out, `group ${clean(g.id)} : ${clean(g.label || g.id)}`);
+    if (g.icon) add(out, `group ${clean(g.id)} icon ${clean(g.icon)}`);
+    if (g.parentId) add(out, `group ${clean(g.id)} parent ${clean(g.parentId)}`);
+  }
+  for (const s of body.services) {
+    add(out, `service ${clean(s.id)} : ${clean(s.label || s.id)}`);
+    if (s.icon) add(out, `service ${clean(s.id)} icon ${clean(s.icon)}`);
+    if (s.parentId) add(out, `service ${clean(s.id)} parent ${clean(s.parentId)}`);
+  }
+  for (const j of body.junctions) {
+    add(out, `junction ${clean(j.id)}`);
+    if (j.parentId) add(out, `junction ${clean(j.id)} parent ${clean(j.parentId)}`);
+  }
+  body.edges.forEach((e, i) => {
+    const source = `${clean(e.source.id)}${e.source.boundary === "group" ? "{group}" : ""}:${e.source.side}`;
+    const target = `${clean(e.target.id)}${e.target.boundary === "group" ? "{group}" : ""}:${e.target.side}`;
+    const base = `edge ${source} -> ${target}`;
+    add(out, e.label ? `${base} : ${clean(e.label)}` : base);
+    add(out, `edge#${i} ${source} -> ${target}${e.label ? ` : ${clean(e.label)}` : ""}`);
+  });
+}
+function factsXyChart(out, body) {
+  if (body.title) add(out, `title ${clean(dequote(body.title))}`);
+  if (body.horizontal) add(out, "orientation horizontal");
+  axisFacts(out, "x-axis", body.xAxis);
+  axisFacts(out, "y-axis", body.yAxis);
+  body.series.forEach((s, i) => {
+    const name = s.name ? clean(dequote(s.name)) : `series#${i}`;
+    add(out, `series ${name} ${s.kind} [${s.values.map(num2).join(",")}]`);
+    add(out, `series#${i} ${s.kind} ${name} [${s.values.map(num2).join(",")}]`);
+  });
+}
+function factsPie(out, body) {
+  if (body.title) add(out, `title ${clean(dequote(body.title))}`);
+  if (body.showData) add(out, "showData true");
+  body.slices.forEach((s, i) => {
+    add(out, `slice ${clean(dequote(s.label))} = ${num2(s.value)}`);
+    add(out, `slice#${i} ${clean(dequote(s.label))} = ${num2(s.value)}`);
+  });
+}
+function factsQuadrant(out, body) {
+  if (body.title) add(out, `title ${clean(dequote(body.title))}`);
+  if (body.xAxis) add(out, `x-axis ${clean(body.xAxis.near)}${body.xAxis.far ? ` -> ${clean(body.xAxis.far)}` : ""}`);
+  if (body.yAxis) add(out, `y-axis ${clean(body.yAxis.near)}${body.yAxis.far ? ` -> ${clean(body.yAxis.far)}` : ""}`);
+  body.quadrants.forEach((q, i) => {
+    if (q) add(out, `quadrant ${i + 1} : ${clean(q)}`);
+  });
+  body.points.forEach((p, i) => {
+    add(out, `point ${clean(dequote(p.label))} @ ${num2(p.x)},${num2(p.y)}`);
+    add(out, `point#${i} ${clean(dequote(p.label))} @ ${num2(p.x)},${num2(p.y)}`);
+  });
+}
+function factsGantt(out, body) {
+  if (body.title) add(out, `title ${clean(body.title)}`);
+  body.sections.forEach((s, si) => {
+    if (s.label) add(out, `section ${clean(s.label)}`);
+    s.tasks.forEach((t, ti) => {
+      add(out, `task ${clean(t.label)}`);
+      add(out, `task#${si}.${ti} ${clean(t.label)}`);
+      if (t.taskId) add(out, `task ${clean(t.label)} id ${clean(t.taskId)}`);
+      if (s.label) add(out, `task ${clean(t.label)} section ${clean(s.label)}`);
+      for (const tag of t.tags) add(out, `task ${clean(t.label)} tag ${tag}`);
+      if (t.start) add(out, `task ${clean(t.label)} start ${clean(t.start)}`);
+      add(out, `task ${clean(t.label)} end ${clean(t.end)}`);
+    });
+  });
+}
+function factsMindmap(out, body) {
+  const visit2 = (node, parent) => {
+    add(out, `node ${clean(node.id)} : ${clean(node.label)}`);
+    add(out, `node ${clean(node.id)} shape ${node.shape}`);
+    if (parent) add(out, edgeFact(parent, node.id));
+    if (node.icon) add(out, `node ${clean(node.id)} icon ${clean(node.icon)}`);
+    if (node.className) add(out, `node ${clean(node.id)} class ${clean(node.className)}`);
+    node.children.forEach((child) => visit2(child, node.id));
+  };
+  visit2(body.root);
+}
+function factsGitGraph(out, body) {
+  add(out, `direction ${body.direction}`);
+  for (const branch of body.branches) {
+    add(out, `branch ${clean(branch.name)} order ${branch.order}`);
+    if (branch.head) add(out, `branch ${clean(branch.name)} head ${clean(branch.head)}`);
+  }
+  for (const commit of body.commits) {
+    add(out, `commit ${clean(commit.id)} branch ${clean(commit.branch)}`);
+    add(out, `commit ${clean(commit.id)} type ${commit.type}`);
+    if (commit.message) add(out, `commit ${clean(commit.id)} message ${clean(commit.message)}`);
+    commit.tags.forEach((tag) => add(out, `commit ${clean(commit.id)} tag ${clean(tag)}`));
+    commit.parents.forEach((parent) => add(out, edgeFact(parent, commit.id, commit.source === "commit" ? void 0 : commit.source)));
+  }
+}
+function axisFacts(out, label, axis) {
+  if (!axis) return;
+  if (axis.name) add(out, `${label} name ${clean(dequote(axis.name))}`);
+  if (axis.categories) add(out, `${label} categories ${axis.categories.map((c) => clean(dequote(c))).join(", ")}`);
+  if (axis.range) add(out, `${label} range ${num2(axis.range.min)} -> ${num2(axis.range.max)}`);
+}
+function edgeFact(from, to, label) {
+  return `edge ${clean(from)} -> ${clean(to)}${label ? ` : ${clean(label)}` : ""}`;
+}
+function add(out, fact) {
+  out.push(fact.replace(/\s+$/g, ""));
+}
+function clean(value) {
+  return String(value ?? "").trim().replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+}
+function dequote(value) {
+  return value.replace(/^"(.*)"$/, "$1");
+}
+function num2(value) {
+  return Number.isInteger(value) ? String(value) : String(Number(value.toPrecision(12)));
+}
+function toFactList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => typeof item === "string" ? item : String(item));
+}
+function specRequired(spec) {
+  if (Array.isArray(spec)) return toFactList(spec);
+  if (!isObjectSpec(spec)) return [];
+  return unique([...toFactList(spec.include), ...toFactList(spec.expected), ...toFactList(spec.require), ...toFactList(spec.required)]);
+}
+function specForbidden(spec) {
+  if (!isObjectSpec(spec)) return [];
+  return unique([...toFactList(spec.exclude), ...toFactList(spec.absent), ...toFactList(spec.forbid), ...toFactList(spec.forbidden), ...toFactList(spec.unexpected)]);
+}
+function isObjectSpec(spec) {
+  return spec !== null && typeof spec === "object" && !Array.isArray(spec);
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
+
+// src/agent/describe.ts
+function describeMermaidSource(source, opts = {}) {
+  const r = parseRegisteredMermaid(source);
+  if (!r.ok) {
+    const first = Array.isArray(r.error) ? r.error[0] : void 0;
+    if (opts.format === "json") {
+      return JSON.stringify({ error: first?.message ?? "parse error", nodes: [], edges: [] });
+    }
+    if (opts.format === "facts") return `error parse ${first?.message ?? "parse error"}`;
+    return `Unparseable Mermaid source: ${first?.message ?? "parse error"}.`;
+  }
+  return describeMermaid(r.value, opts);
+}
+function describeMermaid(d, opts = {}) {
+  if (opts.format === "json") return JSON.stringify(describeMermaidTree(d));
+  if (opts.format === "facts") return describeMermaidFacts(d).join("\n");
+  if (d.body.kind === "flowchart") return describeFlowchart(d);
+  if (d.body.kind === "state") return describeState(d.body);
+  if (d.body.kind === "sequence") return describeSequence(d);
+  if (d.body.kind === "timeline") return describeTimeline(d);
+  if (d.body.kind === "class") return describeClass(d);
+  if (d.body.kind === "er") return describeEr(d);
+  if (d.body.kind === "journey") return describeJourney(d.body);
+  if (d.body.kind === "architecture") return describeArchitecture(d.body);
+  if (d.body.kind === "xychart") return describeXyChart(d.body);
+  if (d.body.kind === "gantt") return describeGantt(d);
+  if (d.body.kind === "pie") return describePie(d.body);
+  if (d.body.kind === "quadrant") return describeQuadrant(d.body);
+  if (d.body.kind === "mindmap") return describeMindmap(d.body);
+  if (d.body.kind === "gitgraph") return describeGitGraph(d.body);
+  if (d.body.kind === "radar") {
+    const axes = d.body.axes.map((a) => a.label).join(", ");
+    const curves = d.body.curves.map((c) => c.label).join(", ");
+    const title = d.body.title ? `"${d.body.title}" ` : "";
+    return `A radar chart ${title}comparing ${d.body.curves.length} curve(s)${curves ? ` (${curves})` : ""} across ${d.body.axes.length} axis/axes${axes ? ` (${axes})` : ""}.`;
+  }
+  if (d.body.kind === "opaque") return describeOpaque(d.kind, d.body.source);
+  if (d.body.kind === "extension") return describeOpaque(d.kind, d.body.source);
+  if (d.body.kind === "preserved") return `An unregistered ${d.body.preservation.upstreamFamilyId ?? d.body.preservation.header} diagram preserved as source. ${d.body.diagnostic.message}`;
+  const _never = d.body;
+  void _never;
+  return `A ${d.kind} diagram.`;
+}
+function describeMermaidTree(d) {
+  const tree = { kind: d.kind, nodes: [], edges: [], entryPoints: [], sinks: [] };
+  if (d.body.kind === "flowchart") {
+    const g = d.body.graph;
+    for (const n of g.nodes.values()) tree.nodes.push({ id: n.id, label: n.label || n.id });
+    for (const e of g.edges) tree.edges.push({ from: e.source, to: e.target, label: e.label || void 0 });
+  } else if (d.body.kind === "state") {
+    const visit2 = (states, transitions) => {
+      for (const s of states) {
+        tree.nodes.push({ id: s.id, label: s.label || s.id });
+        if (s.regions) for (const region of s.regions) visit2(region.states, region.transitions);
+        else if (s.states !== void 0) visit2(s.states, s.transitions ?? []);
+      }
+      for (const t of transitions) tree.edges.push({ from: t.from, to: t.to, label: t.label || void 0 });
+    };
+    visit2(d.body.states, d.body.transitions);
+  } else if (d.body.kind === "sequence") {
+    for (const p of d.body.participants) tree.nodes.push({ id: p.id, label: p.label || p.id });
+    sequenceMessageContexts(d.body).forEach((context) => {
+      const m = context.message;
+      tree.edges.push({
+        from: m.from,
+        to: m.to,
+        label: m.text || void 0,
+        ...context.scope === "fragment" ? {
+          sequence: {
+            fragmentIndex: context.fragmentIndex,
+            branchIndex: context.branchIndex,
+            fragmentKind: context.fragmentKind,
+            ...context.branchLabel ?? (context.branchIndex === 0 ? context.fragmentLabel : void 0) ? { branchLabel: context.branchLabel ?? context.fragmentLabel } : {}
+          }
+        } : {}
+      });
+    });
+  } else if (d.body.kind === "class") {
+    for (const c of d.body.classes) tree.nodes.push({ id: c.id, label: c.label || c.id });
+    for (const r of d.body.relations) tree.edges.push({ from: r.from, to: r.to, label: r.label || r.kind });
+  } else if (d.body.kind === "er") {
+    for (const e of d.body.entities) tree.nodes.push({ id: e.id, label: e.label || e.id });
+    for (const r of d.body.relations) tree.edges.push({ from: r.from, to: r.to, label: r.label || void 0 });
+  } else if (d.body.kind === "timeline") {
+    for (const s of d.body.sections) for (const p of s.periods) {
+      tree.nodes.push({ id: p.id, label: p.label });
+    }
+  } else if (d.body.kind === "journey") {
+    for (const s of d.body.sections) for (const t of s.tasks) {
+      const actors = t.actors.length ? `; ${t.actors.join(", ")}` : "";
+      tree.nodes.push({ id: t.id, label: `${t.text} (score ${t.score}${actors})` });
+    }
+  } else if (d.body.kind === "architecture") {
+    for (const g of d.body.groups) tree.nodes.push({ id: g.id, label: g.label || g.id });
+    for (const s of d.body.services) tree.nodes.push({ id: s.id, label: s.label || s.id });
+    for (const j of d.body.junctions) tree.nodes.push({ id: j.id, label: j.id });
+    for (const e of d.body.edges) tree.edges.push({ from: e.source.id, to: e.target.id, label: e.label || void 0 });
+  } else if (d.body.kind === "xychart") {
+    for (const s of d.body.series) tree.nodes.push({ id: s.id, label: s.name || `${s.kind} series` });
+  } else if (d.body.kind === "gantt") {
+    for (const s of d.body.sections) for (const t of s.tasks) {
+      tree.nodes.push({ id: t.taskId ?? t.id, label: t.label });
+    }
+    const idOf = /* @__PURE__ */ new Map();
+    for (const s of d.body.sections) for (const t of s.tasks) if (t.taskId) idOf.set(t.taskId, t.taskId);
+    for (const s of d.body.sections) for (const t of s.tasks) {
+      for (const [expr, label] of [[t.start, "after"], [t.end, "until"]]) {
+        const m = expr?.match(/^(?:after|until)\s+(.+)$/);
+        if (!m || !expr.startsWith(label)) continue;
+        for (const ref of m[1].split(/\s+/).filter(Boolean)) {
+          if (idOf.has(ref)) tree.edges.push({ from: ref, to: t.taskId ?? t.id, label });
+        }
+      }
+    }
+  } else if (d.body.kind === "pie") {
+    for (const sl of d.body.slices) tree.nodes.push({ id: sl.id, label: `${sl.label} (${sl.value})` });
+  } else if (d.body.kind === "quadrant") {
+    d.body.points.forEach((p, i) => tree.nodes.push({ id: `point-${i}`, label: `${p.label} [${p.x}, ${p.y}]` }));
+  } else if (d.body.kind === "mindmap") {
+    const visit2 = (node, parent) => {
+      tree.nodes.push({ id: node.id, label: node.label });
+      if (parent) tree.edges.push({ from: parent, to: node.id });
+      node.children.forEach((child) => visit2(child, node.id));
+    };
+    visit2(d.body.root);
+  } else if (d.body.kind === "gitgraph") {
+    for (const commit of d.body.commits) {
+      tree.nodes.push({ id: commit.id, label: commit.message || commit.id });
+      commit.parents.forEach((parent) => tree.edges.push({ from: parent, to: commit.id, label: commit.source === "commit" ? void 0 : commit.source }));
+    }
+  } else if (d.body.kind === "radar") {
+    d.body.axes.forEach((a, i) => tree.nodes.push({ id: `axis-${i}`, label: a.label }));
+    d.body.curves.forEach((c, i) => tree.nodes.push({ id: `curve-${i}`, label: c.label }));
+  } else if (d.body.kind === "opaque") {
+    const plugin = getFamily(d.kind);
+    const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+    labels.forEach((label, index) => tree.nodes.push({ id: label.target || `label-${index}`, label: label.text }));
+  } else if (d.body.kind === "extension") {
+    const plugin = getFamily(d.kind);
+    const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(d.body.source);
+    labels.forEach((label, index) => tree.nodes.push({ id: label.target || `label-${index}`, label: label.text }));
+  } else if (d.body.kind === "preserved") {
+  } else {
+    const _never = d.body;
+    void _never;
+  }
+  const incoming = new Set(tree.edges.map((e) => e.to));
+  const outgoing = new Set(tree.edges.map((e) => e.from));
+  for (const n of tree.nodes) {
+    if (!incoming.has(n.id) && outgoing.has(n.id)) tree.entryPoints.push(n.id);
+    if (!outgoing.has(n.id) && incoming.has(n.id)) tree.sinks.push(n.id);
+  }
+  return tree;
+}
+function describeMindmap(body) {
+  let count = 0;
+  let leaves = 0;
+  const top = body.root.children.map((node) => node.label);
+  const visit2 = (node) => {
+    count++;
+    if (node.children.length === 0) leaves++;
+    node.children.forEach(visit2);
+  };
+  visit2(body.root);
+  return `A ${count}-node mindmap rooted at ${body.root.label}, with ${leaves} leaves.${top.length ? ` Main branches: ${top.join(", ")}.` : ""}`;
+}
+function describeGitGraph(body) {
+  const merges = body.commits.filter((commit) => commit.source === "merge").length;
+  const cherries = body.commits.filter((commit) => commit.source === "cherry-pick").length;
+  return `A GitGraph with ${body.commits.length} commits across ${body.branches.length} branches, including ${merges} merges and ${cherries} cherry-picks. Branches: ${body.branches.map((branch) => branch.name).join(", ")}.`;
+}
+function describeFlowchart(d) {
+  const g = d.body.graph;
+  const nodes = Array.from(g.nodes.values());
+  const nodeIds = nodes.map((n) => n.id);
+  const edges = g.edges;
+  const labels = nodes.map((n) => n.label || n.id);
+  const incoming = /* @__PURE__ */ new Map();
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    incoming.set(id, 0);
+    outgoing.set(id, 0);
+  }
+  for (const e of edges) {
+    outgoing.set(e.source, (outgoing.get(e.source) ?? 0) + 1);
+    incoming.set(e.target, (incoming.get(e.target) ?? 0) + 1);
+  }
+  const entries = nodeIds.filter((id) => (incoming.get(id) ?? 0) === 0 && (outgoing.get(id) ?? 0) > 0);
+  const sinks = nodeIds.filter((id) => (outgoing.get(id) ?? 0) === 0 && (incoming.get(id) ?? 0) > 0);
+  const edgeStr = edges.map((e) => {
+    const lbl = e.label ? ` (${e.label})` : "";
+    return `${e.source} -> ${e.target}${lbl}`;
+  });
+  let s = `A ${nodes.length}-node flowchart with ${edges.length} edges. Nodes: ${labels.join(", ")}.`;
+  if (edgeStr.length > 0) s += ` Edges: ${edgeStr.join("; ")}.`;
+  if (entries.length > 0) s += ` Entry points: ${entries.join(", ")}.`;
+  if (sinks.length > 0) s += ` Sinks: ${sinks.join(", ")}.`;
+  return s;
+}
+function describeState(body) {
+  const flat = [];
+  const allTransitions = [];
+  const collect = (states, transitions) => {
+    for (const s2 of states) {
+      flat.push(s2);
+      if (s2.regions) for (const region of s2.regions) collect(region.states, region.transitions);
+      else if (s2.states !== void 0) collect(s2.states, s2.transitions ?? []);
+    }
+    allTransitions.push(...transitions);
+  };
+  collect(body.states, body.transitions);
+  const composites = flat.filter((s2) => s2.states !== void 0 || s2.regions !== void 0);
+  const stateLabels = flat.map((s2) => s2.label || s2.id);
+  const transStr = allTransitions.map((t) => {
+    const lbl = t.label ? ` (${t.label})` : "";
+    return `${t.from} -> ${t.to}${lbl}`;
+  });
+  const starts = body.transitions.filter((t) => t.from === "[*]").map((t) => t.to);
+  let s = `A state diagram with ${flat.length} states and ${allTransitions.length} transitions.`;
+  if (composites.length > 0) s += ` Composite states: ${composites.map((c) => c.label || c.id).join(", ")}.`;
+  if (stateLabels.length > 0) s += ` States: ${stateLabels.join(", ")}.`;
+  const stereotypes = flat.filter((state) => state.stereotype).map((state) => `${state.label || state.id} (${state.stereotype})`);
+  if (stereotypes.length > 0) s += ` Pseudostates: ${stereotypes.join(", ")}.`;
+  if ((body.notes ?? []).length > 0) {
+    s += ` Notes: ${body.notes.map((note) => `${note.side} of ${note.target}: ${note.text}`).join("; ")}.`;
+  }
+  if (transStr.length > 0) s += ` Transitions: ${transStr.join("; ")}.`;
+  if (starts.length > 0) s += ` Initial: ${starts.join(", ")}.`;
+  return s;
+}
+function describeSequence(d) {
+  const parts = d.body.participants;
+  const partStr = parts.map((p) => p.label || p.id).join(", ");
+  let s = `A sequence diagram between ${partStr || "(no participants)"}.`;
+  const interactions = [];
+  let fragmentIndex = 0;
+  for (const statement of d.body.statements) {
+    if (statement.kind === "message") {
+      const message = d.body.messages[statement.ref];
+      if (message) interactions.push(`message ${message.from} -> ${message.to}: ${message.text}`);
+      continue;
+    }
+    if (statement.kind !== "fragment") continue;
+    const branches = statement.fragment.branches.map((branch, branchIndex) => {
+      const label = branch.label ?? (branchIndex === 0 ? statement.fragment.label : void 0);
+      const messages = branch.messages.map((m) => `${m.from} -> ${m.to}: ${m.text}`).join("; ") || "no messages";
+      return `branch ${branchIndex}${label ? ` (${label})` : ""}: ${messages}`;
+    });
+    interactions.push(`fragment ${fragmentIndex} (${statement.fragment.fragmentKind}): ${branches.join(" | ")}`);
+    fragmentIndex++;
+  }
+  if (interactions.length > 0) s += ` Interactions in source order: ${interactions.join("; ")}.`;
+  return s;
+}
+function describeTimeline(d) {
+  const sections = d.body.sections;
+  const sectionLabels = sections.map((s2) => s2.label || s2.id);
+  const periodLabels = [];
+  for (const s2 of sections) for (const p of s2.periods) periodLabels.push(p.label);
+  let s = `A timeline with ${sections.length} sections.`;
+  if (sectionLabels.length > 0) s += ` Sections: ${sectionLabels.join(", ")}.`;
+  if (periodLabels.length > 0) s += ` Periods: ${periodLabels.join(", ")}.`;
+  return s;
+}
+function describeJourney(body) {
+  const sections = body.sections;
+  const taskCount = sections.reduce((n, s2) => n + s2.tasks.length, 0);
+  const actors = [...new Set(sections.flatMap((s2) => s2.tasks.flatMap((t) => t.actors)))];
+  let s = `A user journey${body.title ? ` titled "${body.title}"` : ""} with ${sections.length} sections and ${taskCount} tasks.`;
+  const sectionLabels = sections.map((sec) => sec.label).filter((l) => l !== void 0);
+  if (sectionLabels.length > 0) s += ` Sections: ${sectionLabels.join(", ")}.`;
+  const taskStr = sections.flatMap((sec) => sec.tasks.map((t) => `${t.text} (${t.score})`));
+  if (taskStr.length > 0) s += ` Tasks: ${taskStr.join(", ")}.`;
+  if (actors.length > 0) s += ` Actors: ${actors.join(", ")}.`;
+  return s;
+}
+function describeArchitecture(body) {
+  const groups = body.groups;
+  const services = body.services;
+  const junctions = body.junctions;
+  const edges = body.edges;
+  let s = `An architecture diagram${body.title ? ` titled "${body.title}"` : ""} with ${groups.length} groups, ${services.length} services, and ${edges.length} connections.`;
+  if (body.accessibilityTitle) s += ` Accessible title: ${body.accessibilityTitle}.`;
+  if (body.accessibilityDescription) s += ` Accessible description: ${body.accessibilityDescription.replace(/\n/g, " ")}.`;
+  if (groups.length > 0) s += ` Groups: ${groups.map((g) => g.label || g.id).join(", ")}.`;
+  if (services.length > 0) s += ` Services: ${services.map((sv) => sv.label || sv.id).join(", ")}.`;
+  if (junctions.length > 0) s += ` Junctions: ${junctions.map((j) => j.id).join(", ")}.`;
+  const edgeStr = edges.map((e) => `${e.source.id} -> ${e.target.id}${e.label ? ` (${e.label})` : ""}`);
+  if (edgeStr.length > 0) s += ` Connections: ${edgeStr.join("; ")}.`;
+  return s;
+}
+function describeXyChart(body) {
+  const series = body.series;
+  const orientation = body.horizontal ? "horizontal " : "";
+  let s = `An ${orientation}XY chart${body.title ? ` titled "${body.title}"` : ""} with ${series.length} series.`;
+  const axisDesc = (label, axis) => {
+    if (!axis) return void 0;
+    const parts = [];
+    if (axis.name !== void 0) parts.push(`"${axis.name}"`);
+    if (axis.categories) parts.push(`categories ${axis.categories.join(", ")}`);
+    if (axis.range) parts.push(`range ${axis.range.min}\u2013${axis.range.max}`);
+    return parts.length > 0 ? `${label}: ${parts.join(", ")}` : void 0;
+  };
+  const axes = [axisDesc("x-axis", body.xAxis), axisDesc("y-axis", body.yAxis)].filter((a) => a !== void 0);
+  if (axes.length > 0) s += ` Axes \u2014 ${axes.join("; ")}.`;
+  const seriesStr = series.map((se) => `${se.kind}${se.name ? ` ${se.name}` : ""} [${se.values.join(", ")}]`);
+  if (seriesStr.length > 0) s += ` Series: ${seriesStr.join("; ")}.`;
+  return s;
+}
+function describePie(body) {
+  let s = `A pie chart${body.title ? ` titled "${body.title}"` : ""} with ${body.slices.length} slices.`;
+  const sliceStr = body.slices.map((sl) => `${sl.label} (${sl.value})`);
+  if (sliceStr.length > 0) s += ` Slices: ${sliceStr.join(", ")}.`;
+  return s;
+}
+function describeQuadrant(body) {
+  let s = `A quadrant chart${body.title ? ` titled "${body.title}"` : ""} with ${body.points.length} points.`;
+  const regions = body.quadrants.filter((q) => Boolean(q));
+  if (regions.length > 0) s += ` Quadrants: ${regions.join(", ")}.`;
+  const pointStr = body.points.map((p) => `${p.label} [${p.x}, ${p.y}]`);
+  if (pointStr.length > 0) s += ` Points: ${pointStr.join(", ")}.`;
+  return s;
+}
+function describeClass(d) {
+  const classes = d.body.classes;
+  const relations = d.body.relations;
+  const names = classes.map((c) => c.generic ? `${c.id}<${c.generic}>` : c.id);
+  const relStr = relations.map((r) => `${r.from} ${r.kind} ${r.to}`);
+  let s = `A class diagram with ${classes.length} classes.`;
+  if (names.length > 0) s += ` Classes: ${names.join(", ")}.`;
+  const namespaces = d.body.namespaces ?? [];
+  if (namespaces.length > 0) {
+    const nsStr = namespaces.map((ns) => {
+      const members = classes.filter((c) => c.namespace === ns.name).map((c) => c.id);
+      return `${ns.name} [${members.join(", ")}]`;
+    });
+    s += ` Namespaces: ${nsStr.join("; ")}.`;
+  }
+  if (relStr.length > 0) s += ` Relations: ${relStr.join("; ")}.`;
+  return s;
+}
+function describeEr(d) {
+  const entities = d.body.entities;
+  const relations = d.body.relations;
+  const names = entities.map((e) => e.label ? `${e.id} ("${e.label}")` : e.id);
+  const relStr = relations.map((r) => {
+    const lbl = r.label ? ` (${r.label})` : "";
+    return `${r.from} ${r.leftCard}-${r.rightCard} ${r.to}${lbl}`;
+  });
+  let s = `An ER diagram with ${entities.length} entities.`;
+  if (names.length > 0) s += ` Entities: ${names.join(", ")}.`;
+  if (relStr.length > 0) s += ` Relations: ${relStr.join("; ")}.`;
+  return s;
+}
+function describeGantt(d) {
+  const body = d.body;
+  const tasks = body.sections.flatMap((s2) => s2.tasks);
+  let s = `A Gantt chart${body.title ? ` titled "${body.title}"` : ""} with ${body.sections.filter((sec) => sec.label !== void 0).length} sections and ${tasks.length} tasks.`;
+  try {
+    const schedule = resolveGanttSchedule(parseGanttModel(toMermaidLines(d.canonicalSource)));
+    const fmt = schedule.dateOnly ? "%Y-%m-%d" : "%Y-%m-%d %H:%M";
+    s += ` Schedule: ${formatGanttInstant(schedule.timeMin, fmt)} to ${formatGanttInstant(schedule.timeMax, fmt)}.`;
+    if (schedule.analysis && schedule.analysis.criticalPathTaskIds.length > 0) {
+      s += ` Critical path: ${schedule.analysis.criticalPathTaskIds.join(" -> ")}.`;
+    }
+  } catch {
+  }
+  const sectionLabels = body.sections.map((sec) => sec.label).filter((l) => l !== void 0);
+  if (sectionLabels.length > 0) s += ` Sections: ${sectionLabels.join(", ")}.`;
+  const taskStr = tasks.map((t) => {
+    const bits = [];
+    const status = t.tags.find((tag) => tag === "done" || tag === "active" || tag === "crit");
+    if (status) bits.push(status);
+    if (t.tags.includes("milestone")) bits.push("milestone");
+    if (t.tags.includes("vert")) bits.push("vert marker");
+    if (t.start) bits.push(t.start);
+    bits.push(t.end);
+    return `${t.label} (${bits.join(", ")})`;
+  });
+  if (taskStr.length > 0) s += ` Tasks: ${taskStr.join("; ")}.`;
+  return s;
+}
+function describeOpaque(kind, source) {
+  const plugin = getFamily(kind);
+  const labels = (plugin?.extractLabels ?? extractLabelsGeneric)(source).map((label) => label.text);
+  const unique2 = Array.from(new Set(labels)).filter(Boolean);
+  const family = kind === "xychart" ? "XY chart" : kind;
+  let s = `A ${family} diagram with a source-level body (structured editing not exposed).`;
+  if (unique2.length > 0) s += ` Labels: ${unique2.join(", ")}.`;
+  return s;
+}
+
+// src/ascii/reverse.ts
+var TL = /* @__PURE__ */ new Set(["\u250C", "\u256D"]);
+var TR = /* @__PURE__ */ new Set(["\u2510", "\u256E"]);
+var ARROW_R = /* @__PURE__ */ new Set(["\u25BA", "\u25B6", ">"]);
+var ARROW_L = /* @__PURE__ */ new Set(["\u25C4", "\u25C0", "<"]);
+var ARROW_D = /* @__PURE__ */ new Set(["\u25BC", "v"]);
+var ARROW_U = /* @__PURE__ */ new Set(["\u25B2", "^"]);
+function detectBoxes(rows) {
+  const boxes = [];
+  let counter = 0;
+  for (let y = 0; y < rows.length; y++) {
+    const row = rows[y];
+    for (let x = 0; x < row.length; x++) {
+      const ch = row[x];
+      const isCorner = TL.has(ch) || ch === "+" && isAsciiTopLeft(rows, x, y);
+      if (!isCorner) continue;
+      const box = traceBox(rows, x, y);
+      if (box) {
+        box.id = `N${counter++}`;
+        boxes.push(box);
+      }
+    }
+  }
+  return boxes;
+}
+function isAsciiTopLeft(rows, x, y) {
+  const right = rows[y]?.[x + 1];
+  const below = rows[y + 1]?.[x];
+  return right === "-" && below === "|";
+}
+function traceBox(rows, x0, y0) {
+  const topRow = rows[y0];
+  let x1 = -1;
+  for (let x = x0 + 1; x < topRow.length; x++) {
+    const ch = topRow[x];
+    if (TR.has(ch) || ch === "+") {
+      x1 = x;
+      break;
+    }
+    if (ch !== "\u2500" && ch !== "-") break;
+  }
+  if (x1 < 0) return null;
+  let y1 = -1;
+  for (let y = y0 + 1; y < rows.length; y++) {
+    const ch = rows[y]?.[x0];
+    if (ch === "\u2514" || ch === "\u2570" || ch === "+") {
+      y1 = y;
+      break;
+    }
+    if (ch !== "\u2502" && ch !== "|") break;
+  }
+  if (y1 < 0) return null;
+  const labelParts = [];
+  for (let y = y0 + 1; y < y1; y++) {
+    const seg = (rows[y] ?? "").slice(x0 + 1, x1).replace(/[│|]/g, " ").trim();
+    if (seg) labelParts.push(seg);
+  }
+  return { id: "", label: labelParts.join(" ").trim(), top: y0, left: x0, bottom: y1, right: x1 };
+}
+function boxAt(boxes, x, y, slack = 1) {
+  for (const b of boxes) {
+    if (x >= b.left - slack && x <= b.right + slack && y >= b.top - slack && y <= b.bottom + slack) return b;
+  }
+  return null;
+}
+function detectEdges(rows, boxes) {
+  const edges = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let y = 0; y < rows.length; y++) {
+    const row = rows[y];
+    for (let x = 0; x < row.length; x++) {
+      const ch = row[x];
+      let target = null;
+      let source = null;
+      if (ARROW_R.has(ch)) {
+        target = boxAt(boxes, x + 1, y);
+        source = walkLeft(rows, boxes, x, y);
+      } else if (ARROW_L.has(ch)) {
+        target = boxAt(boxes, x - 1, y);
+        source = walkRight(rows, boxes, x, y);
+      } else if (ARROW_D.has(ch)) {
+        target = boxAt(boxes, x, y + 1);
+        source = walkUp(rows, boxes, x, y);
+      } else if (ARROW_U.has(ch)) {
+        target = boxAt(boxes, x, y - 1);
+        source = walkDown(rows, boxes, x, y);
+      }
+      if (source && target && source.id !== target.id) {
+        const key = `${source.id}->${target.id}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          edges.push([source.id, target.id]);
+        }
+      }
+    }
+  }
+  return edges;
+}
+var HLINE = /* @__PURE__ */ new Set(["\u2500", "-", "\u252C", "\u2534", "\u253C", "\u251C", "\u2524", "+"]);
+var VLINE = /* @__PURE__ */ new Set(["\u2502", "|", "\u252C", "\u2534", "\u253C", "\u251C", "\u2524", "+"]);
+function walkLeft(rows, boxes, x, y) {
+  for (let cx = x - 1; cx >= 0; cx--) {
+    const b = boxAt(boxes, cx, y);
+    if (b) return b;
+    if (!HLINE.has(rows[y]?.[cx] ?? "")) {
+      const up = boxAt(boxes, cx, y - 1), dn = boxAt(boxes, cx, y + 1);
+      return up ?? dn ?? null;
+    }
+  }
+  return null;
+}
+function walkRight(rows, boxes, x, y) {
+  for (let cx = x + 1; cx < (rows[y]?.length ?? 0); cx++) {
+    const b = boxAt(boxes, cx, y);
+    if (b) return b;
+    if (!HLINE.has(rows[y]?.[cx] ?? "")) break;
+  }
+  return null;
+}
+function walkUp(rows, boxes, x, y) {
+  let cx = x;
+  for (let cy = y - 1; cy >= 0; cy--) {
+    const b = boxAt(boxes, cx, cy);
+    if (b) return b;
+    const ch = rows[cy]?.[cx] ?? "";
+    const isJunction = "\u252C\u2534\u253C\u251C\u2524\u2510\u250C\u256E\u256D".includes(ch);
+    if (isJunction && !VLINE.has(rows[cy - 1]?.[cx] ?? "")) {
+      const hop = hopToTrunk(rows, cx, cy);
+      if (hop === null) {
+        const left2 = boxAt(boxes, cx - 1, cy), right2 = boxAt(boxes, cx + 1, cy);
+        return left2 ?? right2 ?? null;
+      }
+      cx = hop;
+      continue;
+    }
+    if (VLINE.has(ch)) continue;
+    if (HLINE.has(ch)) {
+      const hop = hopToTrunk(rows, cx, cy);
+      if (hop !== null) {
+        cx = hop;
+        continue;
+      }
+      const left2 = boxAt(boxes, cx - 1, cy), right2 = boxAt(boxes, cx + 1, cy);
+      return left2 ?? right2 ?? null;
+    }
+    const left = boxAt(boxes, cx - 1, cy), right = boxAt(boxes, cx + 1, cy);
+    return left ?? right ?? null;
+  }
+  return null;
+}
+function hopToTrunk(rows, x, y) {
+  const above = (cx) => rows[y - 1]?.[cx] ?? "";
+  for (let d = 0; d < 200; d++) {
+    for (const cx of [x - d, x + d]) {
+      const here = rows[y]?.[cx] ?? "";
+      if (!HLINE.has(here) && !"\u2510\u250C\u256E\u256D".includes(here)) continue;
+      if (VLINE.has(above(cx))) return cx;
+    }
+  }
+  return null;
+}
+function walkDown(rows, boxes, x, y) {
+  for (let cy = y + 1; cy < rows.length; cy++) {
+    const b = boxAt(boxes, x, cy);
+    if (b) return b;
+    if (!VLINE.has(rows[cy]?.[x] ?? "")) break;
+  }
+  return null;
+}
+function escapeLabel(label) {
+  return /["[\]{}()]/.test(label) ? `["${label.replace(/"/g, "&quot;")}"]` : `[${label}]`;
+}
+function asciiToMermaid(ascii, opts = {}) {
+  if (!ascii.trim()) return err([{ code: "EMPTY", message: "empty ASCII input" }]);
+  const rows = ascii.replace(/\[[0-9;]*m/g, "").split(/\r?\n/);
+  const boxes = detectBoxes(rows);
+  if (boxes.length === 0) return err([{ code: "NO_BOXES", message: "no boxes detected in ASCII; not a recognized flowchart render" }]);
+  const edges = detectEdges(rows, boxes);
+  const dir = opts.direction ?? "LR";
+  const lines = [`flowchart ${dir}`];
+  for (const b of boxes) lines.push(`  ${b.id}${escapeLabel(b.label || b.id)}`);
+  for (const [from, to] of edges) lines.push(`  ${from} --> ${to}`);
+  return ok(lines.join("\n"));
+}
+
+// src/agent/core.ts
+function renderMermaidSVG2(input, opts = {}) {
+  return renderMermaidSVG(input, opts);
+}
+function renderMermaidSVGWithReceipt2(input, opts = {}) {
+  return renderMermaidSVGWithReceipt(input, opts);
+}
+function renderMermaidASCII2(input, opts = {}) {
+  return renderMermaidASCII(input, opts);
+}
+function renderMermaidASCIIWithReceipt2(input, opts = {}) {
+  return renderMermaidASCIIWithReceipt(input, opts);
+}
+function layoutMermaidWithReceipt(input, opts = {}) {
+  const { debug, regions, actions, ...renderOptions } = opts;
+  const layoutOptions = { debug, regions, actions };
+  const preparedInput = prepareRenderInput(input);
+  const source = preparedInput.source;
+  const request = resolveRenderRequestForExecution(source, renderOptions, "layout", layoutOptions, {
+    expectedFamilyId: preparedInput.expectedFamilyId
+  });
+  emitResolvedConfigDiagnostics(request);
+  let diagram;
+  if (typeof input === "string") {
+    const parsed = parseRegisteredMermaid(source);
+    if (!parsed.ok) throw new Error(parsed.error.map((error) => error.message).join("; "));
+    diagram = parsed.value;
+  } else {
+    diagram = input;
+  }
+  const familyLayout = layoutResolvedFamilyToRendered(diagram, request, { debug });
+  if (!familyLayout) throw new Error(`No public layout projection registered for Mermaid family "${diagram.kind}"`);
+  return {
+    layout: enrichRenderedLayout(diagram, familyLayout, layoutOptions),
+    receipt: receiptOf(request)
+  };
+}
+function layoutMermaid(d, opts = {}) {
+  if (d.body.kind === "preserved") {
+    throw new MermaidFamilyDetectionError(familyDetectionDiagnosticFromPreservedBody(d.body));
+  }
+  return layoutMermaidWithReceipt(d, opts).layout;
+}
+function enrichRenderedLayout(d, layout, opts) {
+  const wantRegions = opts.debug || opts.regions;
+  const wantActions = opts.debug || opts.actions;
+  if (!wantRegions && !wantActions) return layout;
+  const next = { ...layout };
+  if (wantRegions) next.regions = buildRenderedRegions(d, layout);
+  if (wantActions) {
+    const nodeIds = new Set(layout.nodes.map((n) => n.id));
+    next.actions = (d.body.kind === "extension" || d.body.kind === "preserved" ? [] : collectActionRecords(d)).filter((a) => nodeIds.has(a.target)).map((a) => ({ ...a, regionId: a.regionId ?? `node:${a.target}` }));
+  }
+  return next;
+}
+function buildRenderedRegions(d, layout) {
+  const regions = [{
+    id: "canvas",
+    kind: "canvas",
+    bounds: { x: toFinite(0), y: toFinite(0), w: layout.bounds.w, h: layout.bounds.h }
+  }];
+  const groupByMember = /* @__PURE__ */ new Map();
+  for (const group of layout.groups) for (const member of group.members) groupByMember.set(member, group.id);
+  const sourceLines = sourceLineHints(d);
+  for (const group of layout.groups) {
+    regions.push({
+      id: `group:${group.id}`,
+      kind: group.regionKind ?? renderedGroupRegionKind(layout.kind),
+      elementId: group.id,
+      parentId: group.parentId ? `group:${group.parentId}` : "canvas",
+      bounds: { x: group.x, y: group.y, w: group.w, h: group.h },
+      sourceLine: d.source.groups.get(group.id)?.line ?? sourceLines.groups.get(group.id)
+    });
+  }
+  for (const node of layout.nodes) {
+    regions.push({
+      id: `node:${node.id}`,
+      kind: "node",
+      elementId: node.id,
+      parentId: groupByMember.has(node.id) ? `group:${groupByMember.get(node.id)}` : "canvas",
+      bounds: { x: node.x, y: node.y, w: node.w, h: node.h },
+      sourceLine: d.source.nodes.get(node.id)?.line ?? sourceLines.nodes.get(node.id)
+    });
+  }
+  for (const edge of layout.edges) {
+    const xs = edge.path.map((p) => p[0]);
+    const ys = edge.path.map((p) => p[1]);
+    if (xs.length > 0 && ys.length > 0) {
+      const minX = Math.min(...xs), maxX = Math.max(...xs), minY = Math.min(...ys), maxY = Math.max(...ys);
+      regions.push({
+        id: `edge:${edge.id}`,
+        kind: "edge",
+        elementId: edge.id,
+        parentId: "canvas",
+        bounds: { x: toFinite(minX), y: toFinite(minY), w: toFinite(Math.max(1, maxX - minX)), h: toFinite(Math.max(1, maxY - minY)) }
+      });
+    }
+    if (edge.label) {
+      const w = Math.max(1, edge.label.text.length * 7);
+      const h = 14;
+      const labelX = d.kind === "sequence" && edge.from === edge.to ? edge.label.x : edge.label.x - w / 2;
+      regions.push({
+        id: `label:${edge.id}`,
+        kind: "label",
+        elementId: edge.id,
+        parentId: `edge:${edge.id}`,
+        bounds: { x: toFinite(labelX), y: toFinite(edge.label.y - h / 2), w: toFinite(w), h: toFinite(h) }
+      });
+    }
+  }
+  return regions;
+}
+function renderedGroupRegionKind(kind) {
+  switch (kind) {
+    case "flowchart":
+    case "state":
+    case "class":
+    case "er":
+    case "architecture":
+      return "cluster";
+    case "gitgraph":
+      return "lane";
+    case "timeline":
+    case "journey":
+    case "gantt":
+      return "band";
+    case "sequence":
+    case "quadrant":
+      return "compartment";
+    case "xychart":
+      return "plot";
+    case "radar":
+      return "ring";
+    default:
+      return "group";
+  }
+}
+function sourceLineHints(d) {
+  const nodes = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  const source = d.body.kind === "opaque" || d.body.kind === "extension" ? d.body.source : d.canonicalSource;
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const text = lines[i];
+    const group = text.match(/^\s*subgraph\s+([A-Za-z0-9_:-]+)/);
+    if (group?.[1] && !groups.has(group[1])) groups.set(group[1], i + 1);
+    for (const node of text.matchAll(/(?:^|[\s&;])([A-Za-z][A-Za-z0-9_:-]*)(?=\s*(?:\[|\(|\{|--|==|-.|$))/g)) {
+      const id = node[1];
+      if (id === "subgraph" || id === "end" || id === d.kind) continue;
+      if (!nodes.has(id)) nodes.set(id, i + 1);
+    }
+  }
+  return { nodes, groups };
+}
+
+export {
+  logToolInvocation,
+  hasOpSchema,
+  validateOp,
+  opMenu,
+  describeOps,
+  opSignatures,
+  mutate,
+  mutateChecked,
+  createMermaid,
+  buildMermaid,
+  verifyMermaid,
+  configWarningsForMermaid,
+  verifySummary,
+  buildChecked,
+  applyOps,
+  DEFAULT_BOUNDS,
+  BOUND_PROVENANCE,
+  measureQuality,
+  checkQuality,
+  layoutCertificateProof,
+  FamilyConformanceError,
+  registerFamily,
+  analyzeMermaid,
+  analyzeMermaidSource,
+  collectActionRecords,
+  ASCII_ROUTE_PARITY_CONTRACT,
+  renderMermaidASCIIWithMeta,
+  describeMermaidFacts,
+  describeMermaidFactsSource,
+  checkMermaid,
+  checkMermaidSource,
+  describeMermaidSource,
+  describeMermaid,
+  describeMermaidTree,
+  asciiToMermaid,
+  renderMermaidSVG2 as renderMermaidSVG,
+  renderMermaidSVGWithReceipt2 as renderMermaidSVGWithReceipt,
+  renderMermaidASCII2 as renderMermaidASCII,
+  renderMermaidASCIIWithReceipt2 as renderMermaidASCIIWithReceipt,
+  layoutMermaidWithReceipt,
+  layoutMermaid
+};
+//# sourceMappingURL=chunk-4QECACIA.js.map