@ai-matrx/rich-content 0.2.4 → 0.2.6

package/dist/mermaid/MermaidView.js

@@ -0,0 +1,68 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useMermaidPreferences } from "../host/app-bindings.js";
+import { useThemeMode } from "../host/app-bindings.js";
+import { MermaidRenderer } from "./MermaidRenderer.js";
+import {
+  DEFAULT_MERMAID_PREFERENCES,
+  resolveMermaidTheme
+} from "./types.js";
+function MermaidView({
+  source,
+  metadata,
+  isStreamActive,
+  className,
+  hideViewportControls,
+  onSvgMounted,
+  viewportMaxHeight,
+  fillHeight
+}) {
+  const prefs = { ...DEFAULT_MERMAID_PREFERENCES, ...useMermaidPreferences() };
+  const appMode = useThemeMode();
+  const options = {
+    theme: resolveMermaidTheme(metadata?.theme ?? prefs.theme, appMode),
+    look: metadata?.look ?? prefs.look,
+    layout: metadata?.layout ?? prefs.layout
+  };
+  return /* @__PURE__ */ jsx(
+    MermaidRenderer,
+    {
+      source,
+      options,
+      isStreamActive,
+      className,
+      hideViewportControls,
+      onSvgMounted,
+      viewportMaxHeight,
+      fillHeight
+    }
+  );
+}
+function StandaloneMermaidView({
+  source,
+  metadata,
+  className,
+  viewportMaxHeight,
+  fillHeight
+}) {
+  const mode = useThemeMode();
+  const options = {
+    theme: resolveMermaidTheme(metadata?.theme ?? DEFAULT_MERMAID_PREFERENCES.theme, mode),
+    look: metadata?.look ?? DEFAULT_MERMAID_PREFERENCES.look,
+    layout: metadata?.layout ?? DEFAULT_MERMAID_PREFERENCES.layout
+  };
+  return /* @__PURE__ */ jsx(
+    MermaidRenderer,
+    {
+      source,
+      options,
+      className,
+      viewportMaxHeight,
+      fillHeight
+    }
+  );
+}
+export {
+  MermaidView,
+  StandaloneMermaidView
+};

package/dist/mermaid/MermaidViewport.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Bounded, fit-aware pan/zoom viewport for a rendered mermaid SVG.
+ *
+ * The sizing problem this solves: a diagram has its own intrinsic aspect ratio,
+ * and naively fitting it to the container width either runs off the screen
+ * vertically (tall flowcharts) or shrinks the text to nothing (wide mind maps).
+ *
+ * The fix is THE DIAGRAM'S FIT RULE (`canvas-adaptive.ts`, one floor for both):
+ *  - Fit the WHOLE drawing when that scale keeps text readable
+ *    (≥ `DIAGRAM_READABLE_ZOOM`, 14px text at ≥ 10px) — a 1648px flowchart in
+ *    a 1370px pane fits whole at ~0.83 instead of overflowing sideways.
+ *  - Otherwise fit the WIDTH, never below that floor; the view starts at the
+ *    top-left and the rest is reached by scrolling / panning.
+ *  - Never auto-upscale past natural (`MAX_FIT`) — that just blurs and wastes
+ *    space; the user can zoom in deliberately.
+ *
+ * Scaling is applied as explicit pixel width/height on the SVG (vector-crisp,
+ * gives the scroll container real content, and keeps `getScreenCTM()` honest so
+ * visual-mode hit-testing stays accurate). Manual zoom (ctrl/cmd-wheel, pinch,
+ * buttons) overrides the auto-fit until the user hits "Fit" again. Plain wheel
+ * scrolls — an embedded diagram must never hijack page scroll.
+ */
+import React from "react";
+interface FrameBox {
+    w: number;
+    h: number;
+}
+/**
+ * Whether a frame resize re-fits the diagram. The pane growing (Expand,
+ * unsplit) or shrinking re-fits unless the person zoomed or panned by hand
+ * since the last fit — their view is theirs. A frame whose height follows its
+ * content (not `fillHeight`) re-fits on WIDTH only: fitting changes the
+ * content height, which would change the frame height and oscillate.
+ */
+export declare function shouldRefitOnResize(input: {
+    previous: FrameBox | null;
+    next: FrameBox;
+    fillHeight: boolean;
+    userAdjusted: boolean;
+    fitPending: boolean;
+}): boolean;
+interface NaturalSize {
+    w: number;
+    h: number;
+}
+export interface MermaidFit {
+    scale: number;
+    /** The whole drawing fits; false = width fit at the floor, view at top-left. */
+    whole: boolean;
+}
+/**
+ * THE diagram fit rule (same floor as `portraitWidthFitViewport`): fit the
+ * whole drawing when that scale is readable, else fit the width down to the
+ * readable floor. `fh` is `Infinity` for a frame with no height bound.
+ */
+export declare function mermaidFitScale(nat: NaturalSize, fw: number, fh: number): MermaidFit;
+interface MermaidViewportProps {
+    /** Rendered SVG markup (sanitized by mermaid under securityLevel strict). */
+    svg: string;
+    className?: string;
+    /** Hide the zoom controls (e.g. tiny inline contexts, popover-open states). */
+    hideControls?: boolean;
+    /** Receives the live SVG element after each injection (visual-mode hook). */
+    onSvgMounted?: (el: SVGSVGElement | null) => void;
+    /**
+     * Px cap on the frame height (chat/inline contexts). The diagram fits within
+     * this height and scrolls past it. Omit + set `fillHeight` for surfaces that
+     * already bound height (canvas workbench, fullscreen).
+     */
+    maxFrameHeight?: number;
+    /** Frame fills its parent's height and fits to the measured height. */
+    fillHeight?: boolean;
+}
+export declare function MermaidViewport({ svg, className, hideControls, onSvgMounted, maxFrameHeight, fillHeight, }: MermaidViewportProps): React.JSX.Element;
+export {};

package/dist/mermaid/MermaidViewport.js

@@ -0,0 +1,286 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { Maximize, Minus, Plus, Scan } from "lucide-react";
+import { DIAGRAM_READABLE_ZOOM } from "../display/blocks/canvas-adaptive.js";
+import { SimpleTooltip } from "../utils/lifted/Tooltip.js";
+import { cn } from "@ai-matrx/design-system";
+const MAX_FIT = 1;
+const MIN_SCALE = 0.1;
+const MAX_SCALE = 8;
+const ZOOM_STEP = 1.25;
+const FRAME_PADDING = 16;
+function shouldRefitOnResize(input) {
+  const { previous, next, fillHeight, userAdjusted, fitPending } = input;
+  if (userAdjusted) return false;
+  if (fitPending || !previous) return true;
+  if (next.w !== previous.w) return true;
+  return fillHeight && next.h !== previous.h;
+}
+function mermaidFitScale(nat, fw, fh) {
+  if (!nat.w || !nat.h || !(fw > 0) || !(fh > 0)) return { scale: 1, whole: true };
+  const whole = Math.min(MAX_FIT, fw / nat.w, fh / nat.h);
+  if (whole >= DIAGRAM_READABLE_ZOOM) return { scale: whole, whole: true };
+  return {
+    scale: Math.min(MAX_FIT, Math.max(DIAGRAM_READABLE_ZOOM, fw / nat.w)),
+    whole: false
+  };
+}
+function MermaidViewport({
+  svg,
+  className,
+  hideControls,
+  onSvgMounted,
+  maxFrameHeight,
+  fillHeight
+}) {
+  const frameRef = useRef(null);
+  const hostRef = useRef(null);
+  const svgRef = useRef(null);
+  const naturalRef = useRef(null);
+  const userAdjustedRef = useRef(false);
+  const frameBoxRef = useRef(null);
+  const fitPendingRef = useRef(false);
+  const [scale, setScale] = useState(1);
+  const [canPan, setCanPan] = useState(false);
+  const dragRef = useRef(null);
+  const pointersRef = useRef(/* @__PURE__ */ new Map());
+  const pinchRef = useRef(null);
+  const frameSize = useCallback(() => {
+    const box = frameBoxRef.current ?? { w: 0, h: 0 };
+    const fw = box.w - FRAME_PADDING;
+    const bound = maxFrameHeight ?? (fillHeight ? box.h : Infinity);
+    return { fw: Math.max(0, fw), fh: Math.max(0, bound - FRAME_PADDING) };
+  }, [maxFrameHeight, fillHeight]);
+  const applyScale = useCallback((s) => {
+    const el = svgRef.current;
+    const nat = naturalRef.current;
+    if (!el || !nat) return;
+    el.style.maxWidth = "none";
+    el.style.width = `${Math.round(nat.w * s)}px`;
+    el.style.height = `${Math.round(nat.h * s)}px`;
+  }, []);
+  const fit = useCallback(() => {
+    const nat = naturalRef.current;
+    if (!nat) return;
+    const { fw, fh } = frameSize();
+    const { scale: s, whole } = mermaidFitScale(nat, fw, fh);
+    userAdjustedRef.current = false;
+    applyScale(s);
+    setScale(s);
+    const frame = frameRef.current;
+    if (!whole && frame) {
+      frame.scrollLeft = 0;
+      frame.scrollTop = 0;
+    }
+  }, [frameSize, applyScale]);
+  const oneToOne = useCallback(() => {
+    userAdjustedRef.current = true;
+    setScale(1);
+  }, []);
+  const clampScale = (s) => Math.min(MAX_SCALE, Math.max(MIN_SCALE, s));
+  const zoomBy = useCallback((factor) => {
+    userAdjustedRef.current = true;
+    setScale((s) => clampScale(s * factor));
+  }, []);
+  const fitRef = useRef(fit);
+  const applyScaleRef = useRef(applyScale);
+  const scaleRef = useRef(scale);
+  useEffect(() => {
+    fitRef.current = fit;
+    applyScaleRef.current = applyScale;
+    scaleRef.current = scale;
+  });
+  useEffect(() => {
+    const host = hostRef.current;
+    if (!host) return void 0;
+    host.innerHTML = svg;
+    const el = host.querySelector("svg");
+    svgRef.current = el;
+    if (el) {
+      el.style.display = "block";
+      const vb = el.viewBox?.baseVal;
+      let nat = vb && vb.width && vb.height ? { w: vb.width, h: vb.height } : null;
+      if (!nat) {
+        try {
+          const bb = el.getBBox();
+          if (bb.width && bb.height) nat = { w: bb.width, h: bb.height };
+        } catch {
+        }
+      }
+      naturalRef.current = nat;
+    } else {
+      naturalRef.current = null;
+    }
+    onSvgMounted?.(el);
+    if (userAdjustedRef.current) applyScaleRef.current(scaleRef.current);
+    else if (frameBoxRef.current) fitRef.current();
+    else fitPendingRef.current = true;
+    return () => {
+      onSvgMounted?.(null);
+    };
+  }, [svg, onSvgMounted]);
+  useEffect(() => {
+    applyScale(scale);
+  }, [scale, applyScale]);
+  useEffect(() => {
+    const frame = frameRef.current;
+    const host = hostRef.current;
+    if (!frame || !host || typeof ResizeObserver === "undefined")
+      return void 0;
+    const ro = new ResizeObserver(() => {
+      setCanPan(
+        frame.scrollWidth > frame.clientWidth + 1 || frame.scrollHeight > frame.clientHeight + 1
+      );
+    });
+    ro.observe(host);
+    return () => ro.disconnect();
+  }, []);
+  useEffect(() => {
+    const frame = frameRef.current;
+    if (!frame || typeof ResizeObserver === "undefined") return void 0;
+    const ro = new ResizeObserver(() => {
+      const next = { w: frame.clientWidth, h: frame.clientHeight };
+      const previous = frameBoxRef.current;
+      frameBoxRef.current = next;
+      const refit = shouldRefitOnResize({
+        previous,
+        next,
+        fillHeight: Boolean(fillHeight),
+        userAdjusted: userAdjustedRef.current,
+        fitPending: fitPendingRef.current
+      });
+      fitPendingRef.current = false;
+      if (refit) fit();
+    });
+    ro.observe(frame);
+    return () => ro.disconnect();
+  }, [fit, fillHeight]);
+  const onWheel = (e) => {
+    if (!e.ctrlKey && !e.metaKey) return;
+    e.preventDefault();
+    zoomBy(e.deltaY < 0 ? 1.1 : 1 / 1.1);
+  };
+  const onPointerDown = (e) => {
+    pointersRef.current.set(e.pointerId, { x: e.clientX, y: e.clientY });
+    if (pointersRef.current.size === 2) {
+      const [a, b] = [...pointersRef.current.values()];
+      pinchRef.current = { distance: Math.hypot(a.x - b.x, a.y - b.y), scale };
+      dragRef.current = null;
+      return;
+    }
+    if (e.button !== 0) return;
+    const frame = frameRef.current;
+    if (!frame) return;
+    dragRef.current = {
+      x: e.clientX,
+      y: e.clientY,
+      left: frame.scrollLeft,
+      top: frame.scrollTop
+    };
+  };
+  const onPointerMove = (e) => {
+    if (pointersRef.current.has(e.pointerId)) {
+      pointersRef.current.set(e.pointerId, { x: e.clientX, y: e.clientY });
+    }
+    if (pinchRef.current && pointersRef.current.size === 2) {
+      const [a, b] = [...pointersRef.current.values()];
+      const distance = Math.hypot(a.x - b.x, a.y - b.y);
+      const ratio = distance / pinchRef.current.distance;
+      userAdjustedRef.current = true;
+      setScale(clampScale(pinchRef.current.scale * ratio));
+      return;
+    }
+    const drag = dragRef.current;
+    const frame = frameRef.current;
+    if (!drag || !frame) return;
+    frame.scrollLeft = drag.left - (e.clientX - drag.x);
+    frame.scrollTop = drag.top - (e.clientY - drag.y);
+    if (frame.scrollLeft !== drag.left || frame.scrollTop !== drag.top) {
+      userAdjustedRef.current = true;
+    }
+  };
+  const onPointerUp = (e) => {
+    pointersRef.current.delete(e.pointerId);
+    if (pointersRef.current.size < 2) pinchRef.current = null;
+    dragRef.current = null;
+  };
+  return /* @__PURE__ */ jsxs("div", { className: cn("group/viewport relative", className), children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: frameRef,
+        className: cn(
+          // 🚨 The page scrolls over a diagram. `overscroll-contain` plus a
+          // vertical scroller here swallowed the mouse wheel wherever a
+          // diagram rendered (verifier round 2). Vertically the diagram is
+          // fitted, so it needs no wheel scroll: a zoomed diagram pans by drag
+          // (which sets scrollTop directly) and zooms with ctrl/cmd-wheel.
+          // Only a full-height viewer (full screen) owns vertical scrolling.
+          fillHeight ? "h-full overflow-auto" : "overflow-x-auto overflow-y-hidden",
+          canPan ? "cursor-grab active:cursor-grabbing" : "cursor-default"
+        ),
+        style: maxFrameHeight ? { maxHeight: maxFrameHeight } : void 0,
+        onWheel,
+        onPointerDown,
+        onPointerMove,
+        onPointerUp,
+        onPointerCancel: onPointerUp,
+        onDoubleClick: fit,
+        children: /* @__PURE__ */ jsx("div", { className: "flex min-h-full min-w-full touch-none select-none items-center-safe justify-center-safe p-2", children: /* @__PURE__ */ jsx("div", { ref: hostRef, className: "shrink-0" }) })
+      }
+    ),
+    !hideControls && /* @__PURE__ */ jsxs("div", { className: "pointer-events-auto absolute bottom-2 right-2 z-10 flex items-center gap-0.5 rounded-md border border-border bg-card/90 p-0.5 opacity-100 shadow-sm backdrop-blur-sm transition-opacity sm:opacity-70 sm:group-hover/viewport:opacity-100 focus-within:opacity-100", children: [
+      /* @__PURE__ */ jsx(SimpleTooltip, { text: "Zoom out", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Zoom out",
+          className: "flex h-11 w-11 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground sm:h-auto sm:w-auto sm:p-1.5",
+          onClick: () => zoomBy(1 / ZOOM_STEP),
+          children: /* @__PURE__ */ jsx(Minus, { className: "h-3.5 w-3.5" })
+        }
+      ) }),
+      /* @__PURE__ */ jsxs("span", { className: "flex h-11 min-w-11 items-center justify-center text-center text-[11px] tabular-nums text-muted-foreground sm:h-auto", children: [
+        Math.round(scale * 100),
+        "%"
+      ] }),
+      /* @__PURE__ */ jsx(SimpleTooltip, { text: "Zoom in", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Zoom in",
+          className: "flex h-11 w-11 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground sm:h-auto sm:w-auto sm:p-1.5",
+          onClick: () => zoomBy(ZOOM_STEP),
+          children: /* @__PURE__ */ jsx(Plus, { className: "h-3.5 w-3.5" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx("span", { className: "mx-0.5 h-4 w-px bg-border" }),
+      /* @__PURE__ */ jsx(SimpleTooltip, { text: "Fit to view (double-click)", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Fit to view",
+          className: "flex h-11 w-11 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground sm:h-auto sm:w-auto sm:p-1.5",
+          onClick: fit,
+          children: /* @__PURE__ */ jsx(Scan, { className: "h-3.5 w-3.5" })
+        }
+      ) }),
+      /* @__PURE__ */ jsx(SimpleTooltip, { text: "Actual size (100%)", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Actual size",
+          className: "flex h-11 w-11 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground sm:h-auto sm:w-auto sm:p-1.5",
+          onClick: oneToOne,
+          children: /* @__PURE__ */ jsx(Maximize, { className: "h-3.5 w-3.5" })
+        }
+      ) })
+    ] })
+  ] });
+}
+export {
+  MermaidViewport,
+  mermaidFitScale,
+  shouldRefitOnResize
+};

package/dist/mermaid/adapters/er.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Entity-relationship adapter. Relationships (`A ||--o{ B : label`) are fully
+ * structurally editable (cardinality, label, reverse, delete, add). Entity
+ * attribute blocks (`ENTITY { … }`) are recognized and re-emitted verbatim —
+ * entities are listed but their attributes are edited in Code mode. An unclosed
+ * block or any unrecognized statement downgrades to code-only.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { ErDoc } from "../model/types.js";
+export declare const erAdapter: MermaidAdapter<ErDoc>;

package/dist/mermaid/adapters/er.js

@@ -0,0 +1,205 @@
+import { splitFrontmatter } from "../diagram-type.js";
+import { MermaidOpError } from "../model/ops.js";
+const ENTITY = `("[^"]*"|[\\w-]+)`;
+const REL_RE = new RegExp(`^${ENTITY}\\s+([|o}{]{2})(--|\\.\\.)([|o}{]{2})\\s+${ENTITY}\\s*:\\s*(.*)$`);
+const BLOCK_OPEN_RE = new RegExp(`^${ENTITY}\\s*\\{\\s*$`);
+const DIRECTION_RE = /^direction\s+\w+\s*$/;
+function stripQuotes(s) {
+  return s.startsWith('"') && s.endsWith('"') ? s.slice(1, -1) : s;
+}
+function parse(source) {
+  const { bodyStartIndex, lines } = splitFrontmatter(source);
+  const doc = {
+    kind: "er",
+    diagramType: "er",
+    frontmatter: lines.slice(0, bodyStartIndex),
+    sourceLines: [],
+    warnings: [],
+    entities: [],
+    relationships: []
+  };
+  const byId = /* @__PURE__ */ new Map();
+  const ensure = (id) => {
+    let e = byId.get(id);
+    if (!e) {
+      e = { id };
+      byId.set(id, e);
+      doc.entities.push(e);
+    }
+    return e;
+  };
+  const body = lines.slice(bodyStartIndex);
+  let headerSeen = false;
+  let counter = 0;
+  for (let i = 0; i < body.length; i++) {
+    const rawLine = body[i];
+    const trimmed = rawLine.trim();
+    if (!trimmed || trimmed.startsWith("%%")) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    if (!headerSeen) {
+      if (!/^erDiagram\s*$/.test(trimmed)) {
+        return { status: "code-only", reason: "unrecognized ER header", diagnostics: [] };
+      }
+      headerSeen = true;
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "header", id: "header" } });
+      continue;
+    }
+    if (DIRECTION_RE.test(trimmed)) {
+      doc.sourceLines.push({ text: rawLine });
+      continue;
+    }
+    const rel = REL_RE.exec(trimmed);
+    if (rel) {
+      ensure(rel[1]);
+      ensure(rel[5]);
+      const r = {
+        id: `r${++counter}`,
+        left: rel[1],
+        right: rel[5],
+        leftCard: rel[2],
+        rightCard: rel[4],
+        identifying: rel[3] === "--",
+        label: stripQuotes(rel[6].trim()),
+        raw: rawLine
+      };
+      doc.relationships.push(r);
+      doc.sourceLines.push({ text: rawLine, ref: { entity: "rel", id: r.id } });
+      continue;
+    }
+    const block = BLOCK_OPEN_RE.exec(trimmed);
+    if (block) {
+      const blockLines = [rawLine];
+      let closed = false;
+      while (i + 1 < body.length) {
+        i++;
+        blockLines.push(body[i]);
+        if (body[i].trim() === "}") {
+          closed = true;
+          break;
+        }
+      }
+      if (!closed) {
+        return { status: "code-only", reason: "unclosed entity block", diagnostics: [] };
+      }
+      const e = ensure(block[1]);
+      e.blockRaw = blockLines;
+      for (const bl of blockLines) doc.sourceLines.push({ text: bl });
+      continue;
+    }
+    return {
+      status: "code-only",
+      reason: `unrecognized statement: "${trimmed.slice(0, 40)}"`,
+      diagnostics: []
+    };
+  }
+  if (!headerSeen) {
+    return { status: "invalid", diagnostics: [{ line: 1, message: "missing erDiagram header", severity: "error" }] };
+  }
+  return { status: "ok", doc };
+}
+function emitLabel(label) {
+  if (label === "") return '""';
+  return /[\s:]/.test(label) ? `"${label.replace(/"/g, "'")}"` : label;
+}
+function relationshipLine(r) {
+  const line = r.identifying ? "--" : "..";
+  return `${r.left} ${r.leftCard}${line}${r.rightCard} ${r.right} : ${emitLabel(r.label)}`;
+}
+function serialize(doc) {
+  const out = [...doc.frontmatter];
+  const relById = new Map(doc.relationships.map((r) => [r.id, r]));
+  const emitted = /* @__PURE__ */ new Set();
+  for (const line of doc.sourceLines) {
+    const indent = /^(\s*)/.exec(line.text)?.[1] ?? "";
+    if (!line.ref) {
+      out.push(line.text);
+      continue;
+    }
+    if (line.ref.entity === "rel") {
+      const r = relById.get(line.ref.id);
+      if (!r) continue;
+      emitted.add(r.id);
+      out.push(r.dirty ? `${indent}${relationshipLine(r)}` : line.text);
+      continue;
+    }
+    out.push(line.text);
+  }
+  const additions = [];
+  for (const r of doc.relationships) {
+    if (!emitted.has(r.id) && !r.raw) additions.push(`  ${relationshipLine(r)}`);
+  }
+  return [...out, ...additions].join("\n");
+}
+function mirrorCard(token) {
+  return token.split("").reverse().map((c) => c === "{" ? "}" : c === "}" ? "{" : c).join("");
+}
+function applyOp(doc, op) {
+  const next = structuredClone(doc);
+  const eop = op;
+  const findRel = (id) => {
+    const r = next.relationships.find((x) => x.id === id);
+    if (!r) throw new MermaidOpError("That relationship no longer exists");
+    return r;
+  };
+  switch (eop.type) {
+    case "addRelationship": {
+      if (!next.entities.some((e) => e.id === eop.left) || !next.entities.some((e) => e.id === eop.right)) {
+        throw new MermaidOpError("Both entities must already exist");
+      }
+      next.relationships.push({
+        id: `r_a${next.relationships.length + 1}`,
+        left: eop.left,
+        right: eop.right,
+        leftCard: "||",
+        rightCard: "o{",
+        identifying: true,
+        label: eop.label ?? "relates to",
+        added: true
+      });
+      return next;
+    }
+    case "setRelationshipLabel": {
+      const r = findRel(eop.id);
+      r.label = eop.label;
+      r.dirty = true;
+      return next;
+    }
+    case "setRelationshipCardinality": {
+      const r = findRel(eop.id);
+      if (eop.leftCard !== void 0) r.leftCard = eop.leftCard;
+      if (eop.rightCard !== void 0) r.rightCard = eop.rightCard;
+      if (eop.identifying !== void 0) r.identifying = eop.identifying;
+      r.dirty = true;
+      return next;
+    }
+    case "reverseRelationship": {
+      const r = findRel(eop.id);
+      const newLeft = mirrorCard(r.rightCard);
+      const newRight = mirrorCard(r.leftCard);
+      [r.left, r.right] = [r.right, r.left];
+      r.leftCard = newLeft;
+      r.rightCard = newRight;
+      r.dirty = true;
+      return next;
+    }
+    case "deleteRelationship": {
+      findRel(eop.id);
+      next.relationships = next.relationships.filter((r) => r.id !== eop.id);
+      return next;
+    }
+    default:
+      throw new MermaidOpError("Unsupported operation for ER diagrams");
+  }
+}
+const erAdapter = {
+  diagramType: "er",
+  parse,
+  serialize,
+  applyOp,
+  vocabulary: { node: "Entity", addNode: "Add entity", edge: "Relationship" }
+};
+export {
+  erAdapter
+};

package/dist/mermaid/adapters/flowchart.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Flowchart adapter — tolerant line-based parse / lossless serialize / ops.
+ *
+ * Fidelity strategy: every body line is kept in order (SourceLine). Lines
+ * bound to entities re-emit verbatim unless the entity is dirty (regenerate,
+ * preserving indentation) or deleted (skip). Unrecognized lines that could
+ * plausibly be structural force `code-only` — never guess.
+ */
+import type { MermaidAdapter } from "../model/adapter.js";
+import type { FlowchartDoc } from "../model/types.js";
+/** Adapter-owned color palette — emitted as classDef mmdp_<key> lines. */
+export declare const FLOW_PALETTE: Record<string, {
+    classDef: string;
+    swatch: string;
+    label: string;
+}>;
+export declare const flowchartAdapter: MermaidAdapter<FlowchartDoc>;