@pfdsl/graphviz-exporter 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 takasek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @pfdsl/graphviz-exporter
+
+Renders [PFDSL](https://github.com/takasek/pfdsl) graphs to DOT / SVG / PDF / PNG.
+
+## Requirements
+
+Node.js ≥ 18 (ESM only).
+
+## API
+
+```ts
+import { exportDot, exportDiffDot, svgToBinary } from "@pfdsl/graphviz-exporter";
+
+// Render a graph as a DOT string
+const dot = exportDot(graph, frontmatter, options);
+
+// Render a diff as a DOT string
+const dot = exportDiffDot(graph, frontmatter, options);
+
+// Convert an SVG string to PDF or PNG (requires @hpcc-js/wasm)
+const pdf = await svgToBinary(svgString, "pdf");
+```
+
+See [`ExportOptions`](src/index.ts) for available options.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { Graph, Frontmatter } from '@pfdsl/core';
+
+interface ExportOptions {
+    /** Override rankdir; defaults to frontmatter.layout.direction or 'LR'. */
+    rankdir?: "LR" | "RL" | "TB" | "BT";
+    /** Color for feedback edges. Default '#888888'. */
+    feedbackColor?: string;
+    /** Title for the graph; defaults to frontmatter.title. */
+    graphLabel?: string;
+}
+declare function exportDot(graph: Graph, frontmatter?: Frontmatter | null, options?: ExportOptions): string;
+declare function exportDiffDot(a: Graph, fmA: Frontmatter | null, b: Graph, fmB: Frontmatter | null, options?: ExportOptions): string;
+type BinaryFormat = "pdf" | "png";
+declare function svgToBinary(svg: string, format: BinaryFormat): Promise<Buffer>;
+
+export { type BinaryFormat, type ExportOptions, exportDiffDot, exportDot, svgToBinary };

package/dist/index.js

@@ -0,0 +1,629 @@
+// src/index.ts
+import { diffGraphs, resolveMeta as resolveMeta2 } from "@pfdsl/core";
+
+// src/label.ts
+var MIN_WRAP_RATIO = 0.3;
+var LINE_HEAD_FORBIDDEN = /[、。，．）}\]」』】！？!?]/;
+var LINE_END_FORBIDDEN = /[（{[「『【]/;
+var BREAK_CHARS = /[、。，．,.\s()（）「」『』【】[\]=]/;
+var FONT_SIZE = 14;
+var CHAR_EM = {
+  " ": 250,
+  "!": 333,
+  '"': 408,
+  "#": 500,
+  $: 500,
+  "%": 833,
+  "&": 778,
+  "'": 180,
+  "(": 333,
+  ")": 333,
+  "*": 500,
+  "+": 564,
+  ",": 250,
+  "-": 333,
+  ".": 250,
+  "/": 278,
+  "0": 500,
+  "1": 500,
+  "2": 500,
+  "3": 500,
+  "4": 500,
+  "5": 500,
+  "6": 500,
+  "7": 500,
+  "8": 500,
+  "9": 500,
+  ":": 278,
+  ";": 278,
+  "<": 564,
+  "=": 564,
+  ">": 564,
+  "?": 444,
+  "@": 921,
+  A: 722,
+  B: 667,
+  C: 667,
+  D: 722,
+  E: 611,
+  F: 556,
+  G: 722,
+  H: 722,
+  I: 333,
+  J: 389,
+  K: 722,
+  L: 611,
+  M: 889,
+  N: 722,
+  O: 722,
+  P: 556,
+  Q: 722,
+  R: 667,
+  S: 556,
+  T: 611,
+  U: 722,
+  V: 722,
+  W: 944,
+  X: 722,
+  Y: 722,
+  Z: 611,
+  "[": 333,
+  "\\": 278,
+  "]": 333,
+  "^": 469,
+  _: 500,
+  "`": 333,
+  a: 444,
+  b: 500,
+  c: 444,
+  d: 500,
+  e: 444,
+  f: 333,
+  g: 500,
+  h: 500,
+  i: 278,
+  j: 278,
+  k: 500,
+  l: 278,
+  m: 778,
+  n: 500,
+  o: 500,
+  p: 500,
+  q: 500,
+  r: 333,
+  s: 389,
+  t: 278,
+  u: 500,
+  v: 500,
+  w: 722,
+  x: 500,
+  y: 500,
+  z: 444,
+  "{": 480,
+  "|": 200,
+  "}": 480,
+  "~": 541
+};
+function measureTextWidth(text) {
+  let w = 0;
+  for (const ch of text) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= 12352 && cp <= 12447 || // hiragana
+    cp >= 12448 && cp <= 12543 || // katakana
+    cp >= 19968 && cp <= 40959 || // CJK unified
+    cp >= 63744 && cp <= 64255 || // CJK compatibility
+    cp >= 65280 && cp <= 65519) {
+      w += FONT_SIZE;
+    } else {
+      w += (CHAR_EM[ch] ?? 500) / 1e3 * FONT_SIZE;
+    }
+  }
+  return w;
+}
+function wrapLabel(text, maxWidthPx) {
+  if (measureTextWidth(text) <= maxWidthPx) return text;
+  const lines = [];
+  let currentLine = "";
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    const testLine = currentLine + char;
+    if (measureTextWidth(testLine) > maxWidthPx && currentLine.length > 0) {
+      let breakIndex = -1;
+      if (!BREAK_CHARS.test(char)) {
+        for (let j = currentLine.length - 1; j >= 0; j--) {
+          const breakChar = currentLine[j];
+          if (BREAK_CHARS.test(breakChar)) {
+            if (LINE_END_FORBIDDEN.test(breakChar)) continue;
+            const widthToBreak = measureTextWidth(
+              currentLine.substring(0, j + 1)
+            );
+            if (widthToBreak > maxWidthPx * MIN_WRAP_RATIO) {
+              breakIndex = j;
+              break;
+            }
+          }
+        }
+      }
+      if (breakIndex >= 0) {
+        const breakChar = currentLine[breakIndex];
+        if (LINE_HEAD_FORBIDDEN.test(breakChar)) {
+          lines.push(currentLine.substring(0, breakIndex + 1));
+          currentLine = currentLine.substring(breakIndex + 1) + char;
+        } else {
+          lines.push(currentLine.substring(0, breakIndex));
+          currentLine = currentLine.substring(breakIndex + 1) + char;
+        }
+      } else {
+        lines.push(currentLine);
+        currentLine = char;
+      }
+    } else {
+      currentLine = testLine;
+    }
+  }
+  if (currentLine) lines.push(currentLine);
+  return lines.join("\n");
+}
+
+// src/node-attrs.ts
+import { resolveMeta, STYLE_ATTRS } from "@pfdsl/core";
+var DEFAULT_FEEDBACK_COLOR = "#888888";
+var QUOTE_BACKSLASH_RE = /\\/g;
+var QUOTE_DQUOTE_RE = /"/g;
+var QUOTE_NEWLINE_RE = /\n/g;
+var CJK_RE = /[　-鿿豈-﫿！-｠]/u;
+function quote(s) {
+  return '"' + s.replace(QUOTE_BACKSLASH_RE, "\\\\").replace(QUOTE_DQUOTE_RE, '\\"').replace(QUOTE_NEWLINE_RE, "\\n") + '"';
+}
+function calcMinWidth(label) {
+  if (!CJK_RE.test(label)) return void 0;
+  let maxUnits = 0;
+  for (const line of label.split("\n")) {
+    let units = 0;
+    for (const ch of line) {
+      const cp = ch.codePointAt(0) ?? 0;
+      const isCjk = cp >= 12288 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65281 && cp <= 65376;
+      units += isCjk ? 2 : 1;
+    }
+    maxUnits = Math.max(maxUnits, units);
+  }
+  return Math.max(0.75, maxUnits * 0.1 + 0.3);
+}
+function darkenHex(color, factor = 0.7) {
+  const m6 = /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/.exec(color);
+  if (m6) {
+    const r = Math.round(parseInt(m6[1], 16) * factor);
+    const g = Math.round(parseInt(m6[2], 16) * factor);
+    const b = Math.round(parseInt(m6[3], 16) * factor);
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  const m3 = /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/.exec(color);
+  if (m3) {
+    const r = Math.round(parseInt(m3[1] + m3[1], 16) * factor);
+    const g = Math.round(parseInt(m3[2] + m3[2], 16) * factor);
+    const b = Math.round(parseInt(m3[3] + m3[3], 16) * factor);
+    return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  }
+  return void 0;
+}
+function buildXlabel(id, kind, fm) {
+  if (!fm) return void 0;
+  const parts = [];
+  if (kind === "artifact") {
+    const meta = fm.artifact?.[id];
+    if (meta?.status) parts.push(meta.status);
+    for (const tag of meta?.tags ?? []) parts.push(tag);
+  } else if (kind === "process") {
+    const meta = fm.process?.[id];
+    for (const tag of meta?.tags ?? []) parts.push(tag);
+  }
+  return parts.length > 0 ? parts.join(", ") : void 0;
+}
+function resolveStyleAttrs(id, kind, fm) {
+  if (!fm) return {};
+  if (kind === "group") return {};
+  const meta = resolveMeta(fm, kind, id);
+  const styleAttrs = {};
+  const tags = meta?.tags ?? [];
+  for (let i = tags.length - 1; i >= 0; i--) {
+    const tag = tags[i];
+    if (tag !== void 0)
+      Object.assign(styleAttrs, fm.tag?.[tag]?.style ?? {});
+  }
+  if (kind === "artifact") {
+    const status = meta?.status;
+    if (status) Object.assign(styleAttrs, fm.statusStyles?.[status] ?? {});
+  }
+  return styleAttrs;
+}
+function nodeAttrs(id, kind, fm, boundaryArtifacts = /* @__PURE__ */ new Set()) {
+  const shape = kind === "process" ? "ellipse" : "box";
+  const meta = resolveMeta(fm, kind, id);
+  const nodeLabel = meta?.label;
+  const description = meta?.description;
+  const ameta = kind === "artifact" ? meta : void 0;
+  const criteria = ameta?.criteria;
+  const locationRaw = ameta?.location;
+  const locationArray = typeof locationRaw === "string" ? [locationRaw] : Array.isArray(locationRaw) && locationRaw.length > 0 ? locationRaw : void 0;
+  const location = locationArray?.join(", ");
+  const revises = ameta?.revises;
+  const maxWidth = typeof fm?.layout?.maxWidth === "number" ? fm.layout.maxWidth : void 0;
+  const wrappedNodeLabel = nodeLabel && maxWidth ? wrapLabel(nodeLabel, maxWidth) : nodeLabel;
+  const label = wrappedNodeLabel ? `${id}
+${wrappedNodeLabel}` : id;
+  const wrappingOccurred = wrappedNodeLabel !== nodeLabel;
+  const originalLabel = nodeLabel ?? id;
+  const tooltipParts = [originalLabel];
+  if (description) tooltipParts.push(`
+
+${description}`);
+  const KNOWN_TOOLTIP_SKIP = /* @__PURE__ */ new Set([
+    "label",
+    // shown as node label
+    "description",
+    // rendered first with double newline
+    "status",
+    // shown as node color and xlabel
+    "tags",
+    // shown as xlabel
+    "group",
+    // shown as cluster border
+    "parts",
+    // structural — child nodes are visible in graph
+    "location",
+    // appended last with dedicated formatting
+    "boundary"
+    // subflow id remapping — not human-readable as-is
+  ]);
+  const knownFields = [];
+  if (criteria) knownFields.push(["criteria", criteria]);
+  if (revises) knownFields.push(["revises", revises]);
+  if (typeof meta?.owner === "string") knownFields.push(["owner", meta.owner]);
+  if (typeof meta?.command === "string")
+    knownFields.push(["command", meta.command]);
+  if (typeof meta?.subflow === "string")
+    knownFields.push(["subflow", meta.subflow]);
+  const extraFields = meta ? Object.entries(meta).filter(([k, v]) => {
+    if (KNOWN_TOOLTIP_SKIP.has(k)) return false;
+    if (knownFields.some(([kf]) => kf === k)) return false;
+    if (typeof v === "string") return true;
+    if (Array.isArray(v) && v.length > 0 && v.every((i) => typeof i === "string"))
+      return true;
+    return false;
+  }).map(([k, v]) => [
+    k,
+    Array.isArray(v) ? v.join(", ") : v
+  ]) : [];
+  for (const [key, val] of [...knownFields, ...extraFields]) {
+    const formatted = val.includes("\n") ? `
+${key}:
+${val.split("\n").map((l) => `  ${l}`).join("\n")}` : `
+${key}: ${val}`;
+    tooltipParts.push(formatted);
+  }
+  if (location) tooltipParts.push(`
+location: ${location}`);
+  const tooltip = tooltipParts.length > 1 ? tooltipParts.join("") : wrappingOccurred ? originalLabel : void 0;
+  const styleAttrs = resolveStyleAttrs(id, kind, fm);
+  const xlabel = buildXlabel(id, kind, fm);
+  const firstLoc = locationArray?.[0];
+  const singleUrl = locationArray?.length === 1 && firstLoc?.includes("://") ? firstLoc : void 0;
+  const minWidth = calcMinWidth(label);
+  const attrs = [`shape=${shape}`, `label=${quote(label)}`];
+  if (tooltip !== void 0) attrs.push(`tooltip=${quote(tooltip)}`);
+  if (singleUrl) attrs.push(`href=${quote(singleUrl)}`);
+  if (minWidth !== void 0) attrs.push(`width=${minWidth.toFixed(2)}`);
+  if (xlabel !== void 0) attrs.push(`xlabel=${quote(xlabel)}`);
+  for (const key of STYLE_ATTRS) {
+    const v = styleAttrs[key];
+    if (v !== void 0) attrs.push(`${key}=${quote(v)}`);
+  }
+  if (kind === "artifact" && boundaryArtifacts.has(id) && styleAttrs.penwidth === void 0) {
+    attrs.push(`penwidth="2"`);
+  }
+  if (kind === "process" && typeof meta?.subflow === "string") {
+    attrs.push(`peripheries="2"`);
+  }
+  return `[${attrs.join(", ")}]`;
+}
+
+// src/index.ts
+function exportDot(graph, frontmatter = null, options = {}) {
+  const rankdir = options.rankdir ?? frontmatter?.layout?.direction ?? "LR";
+  const feedbackColor = options.feedbackColor ?? DEFAULT_FEEDBACK_COLOR;
+  const graphLabel = options.graphLabel ?? frontmatter?.title;
+  const lines = [];
+  lines.push("digraph PFDSL {");
+  lines.push(`  rankdir=${rankdir};`);
+  lines.push("  newrank=true;");
+  if (graphLabel !== void 0) {
+    lines.push(`  label=${quote(String(graphLabel))};`);
+    lines.push('  labelloc="t";');
+  }
+  lines.push("");
+  const nodeGroup = /* @__PURE__ */ new Map();
+  if (frontmatter?.group) {
+    for (const [id, meta] of Object.entries(frontmatter.artifact ?? {})) {
+      if (meta.group !== void 0) nodeGroup.set(id, meta.group);
+    }
+    for (const [id, meta] of Object.entries(frontmatter.process ?? {})) {
+      if (meta.group !== void 0) nodeGroup.set(id, meta.group);
+    }
+  }
+  const hasIncoming = /* @__PURE__ */ new Set();
+  const hasOutgoing = /* @__PURE__ */ new Set();
+  for (const e of graph.primaryEdges) {
+    hasIncoming.add(e.to);
+    hasOutgoing.add(e.from);
+  }
+  const boundaryArtifacts = /* @__PURE__ */ new Set();
+  for (const [id, kind] of graph.nodes) {
+    if (kind === "artifact" && (!hasIncoming.has(id) || !hasOutgoing.has(id))) {
+      boundaryArtifacts.add(id);
+    }
+  }
+  const nodeIds = [...graph.nodes.keys()].sort();
+  const groupedNodes = /* @__PURE__ */ new Map();
+  const ungroupedIds = [];
+  for (const id of nodeIds) {
+    if (graph.nodes.get(id) === "group") continue;
+    const gid = nodeGroup.get(id);
+    if (gid !== void 0 && frontmatter?.group?.[gid] !== void 0) {
+      if (!groupedNodes.has(gid)) groupedNodes.set(gid, []);
+      groupedNodes.get(gid).push(id);
+    } else {
+      ungroupedIds.push(id);
+    }
+  }
+  const groupDefs = frontmatter?.group ?? {};
+  const groupChildren = /* @__PURE__ */ new Map();
+  const rootGroups = [];
+  for (const gid of Object.keys(groupDefs).sort()) {
+    const parentId = groupDefs[gid]?.parent;
+    if (parentId !== void 0 && groupDefs[parentId] !== void 0) {
+      if (!groupChildren.has(parentId)) groupChildren.set(parentId, []);
+      groupChildren.get(parentId).push(gid);
+    } else {
+      rootGroups.push(gid);
+    }
+  }
+  function emitGroupBlock(gid, indent) {
+    const gm = groupDefs[gid];
+    const inner = `${indent}  `;
+    lines.push(`${indent}subgraph cluster_${gid} {`);
+    if (gm.label !== void 0)
+      lines.push(`${inner}label=${quote(String(gm.label))};`);
+    if (gm.color !== void 0) {
+      const fillColor = String(gm.color);
+      const strokeColor = darkenHex(fillColor) ?? fillColor;
+      lines.push(`${inner}color=${quote(strokeColor)};`);
+      lines.push(`${inner}style="filled";`);
+      lines.push(`${inner}fillcolor=${quote(fillColor)};`);
+    }
+    for (const childGid of (groupChildren.get(gid) ?? []).sort()) {
+      emitGroupBlock(childGid, inner);
+    }
+    for (const id of groupedNodes.get(gid) ?? []) {
+      lines.push(
+        `${inner}${quote(id)} ${nodeAttrs(id, graph.nodes.get(id), frontmatter, boundaryArtifacts)};`
+      );
+    }
+    lines.push(`${indent}}`);
+  }
+  for (const gid of rootGroups) {
+    if (groupedNodes.has(gid) || (groupChildren.get(gid)?.length ?? 0) > 0) {
+      emitGroupBlock(gid, "  ");
+    }
+  }
+  for (const id of ungroupedIds) {
+    const kind = graph.nodes.get(id);
+    lines.push(
+      `  ${quote(id)} ${nodeAttrs(id, kind, frontmatter, boundaryArtifacts)};`
+    );
+  }
+  if (graph.primaryEdges.length > 0 || graph.feedbackEdges.length > 0) {
+    lines.push("");
+  }
+  for (const e of graph.primaryEdges) {
+    lines.push(`  ${quote(e.from)} -> ${quote(e.to)};`);
+  }
+  for (const e of graph.feedbackEdges) {
+    lines.push(
+      `  ${quote(e.artifact)} -> ${quote(e.process)} [style=dashed, color=${quote(feedbackColor)}, constraint=false];`
+    );
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+function exportDiffDot(a, fmA, b, fmB, options = {}) {
+  const report = diffGraphs(a, b, fmA, fmB);
+  const added = new Set(report.addedNodes);
+  const removed = new Set(report.removedNodes);
+  const changed = new Set(report.changedNodes);
+  const primaryEdgeMap = /* @__PURE__ */ new Map();
+  for (const e of a.primaryEdges) {
+    const key = `${e.from} -> ${e.to}`;
+    if (!primaryEdgeMap.has(key))
+      primaryEdgeMap.set(key, { from: e.from, to: e.to, status: "unchanged" });
+  }
+  for (const e of b.primaryEdges) {
+    const key = `${e.from} -> ${e.to}`;
+    if (!primaryEdgeMap.has(key))
+      primaryEdgeMap.set(key, { from: e.from, to: e.to, status: "unchanged" });
+  }
+  const addedEdgesSet = new Set(report.addedEdges);
+  const removedEdgesSet = new Set(report.removedEdges);
+  for (const [key, val] of primaryEdgeMap) {
+    if (addedEdgesSet.has(key)) val.status = "added";
+    else if (removedEdgesSet.has(key)) val.status = "removed";
+  }
+  const feedbackEdgeMap = /* @__PURE__ */ new Map();
+  for (const e of a.feedbackEdges) {
+    const key = `${e.artifact} -> ${e.process}`;
+    if (!feedbackEdgeMap.has(key))
+      feedbackEdgeMap.set(key, {
+        artifact: e.artifact,
+        process: e.process,
+        status: "unchanged"
+      });
+  }
+  for (const e of b.feedbackEdges) {
+    const key = `${e.artifact} -> ${e.process}`;
+    if (!feedbackEdgeMap.has(key))
+      feedbackEdgeMap.set(key, {
+        artifact: e.artifact,
+        process: e.process,
+        status: "unchanged"
+      });
+  }
+  const addedFeedbackSet = new Set(report.addedFeedback);
+  const removedFeedbackSet = new Set(report.removedFeedback);
+  for (const [key, val] of feedbackEdgeMap) {
+    if (addedFeedbackSet.has(key)) val.status = "added";
+    else if (removedFeedbackSet.has(key)) val.status = "removed";
+  }
+  const visibleNodes = /* @__PURE__ */ new Set([...added, ...removed, ...changed]);
+  for (const [, val] of primaryEdgeMap) {
+    if (val.status === "added" || val.status === "removed") {
+      visibleNodes.add(val.from);
+      visibleNodes.add(val.to);
+    }
+  }
+  for (const [, val] of feedbackEdgeMap) {
+    if (val.status === "added" || val.status === "removed") {
+      visibleNodes.add(val.artifact);
+      visibleNodes.add(val.process);
+    }
+  }
+  const visiblePrimaryEdges = [...primaryEdgeMap.entries()].filter(([, val]) => val.status === "added" || val.status === "removed").sort(([a2], [b2]) => a2.localeCompare(b2));
+  const visibleFeedbackEdges = [...feedbackEdgeMap.entries()].filter(([, val]) => val.status === "added" || val.status === "removed").sort(([a2], [b2]) => a2.localeCompare(b2));
+  const rankdir = options.rankdir ?? fmB?.layout?.direction ?? fmA?.layout?.direction ?? "LR";
+  const title = options.graphLabel ?? fmB?.title;
+  const graphLabel = title ? `${title} \u2014 diff` : "diff";
+  const legend = "green = added \xB7 red = removed \xB7 yellow = changed";
+  const fullLabel = `${graphLabel}
+${legend}`;
+  const lines = [];
+  lines.push("digraph PFDSL {");
+  lines.push(`  rankdir=${rankdir};`);
+  lines.push("  newrank=true;");
+  lines.push(`  label=${quote(fullLabel)};`);
+  lines.push('  labelloc="t";');
+  lines.push("");
+  if (added.size === 0 && removed.size === 0 && changed.size === 0) {
+    lines.push(
+      '  "_nodiff" [shape=note, label="No structural or metadata changes"];'
+    );
+    lines.push("}");
+    return `${lines.join("\n")}
+`;
+  }
+  const maxWidth = typeof fmB?.layout?.maxWidth === "number" ? fmB.layout.maxWidth : typeof fmA?.layout?.maxWidth === "number" ? fmA.layout.maxWidth : void 0;
+  for (const id of [...visibleNodes].sort()) {
+    const kind = b.nodes.get(id) ?? a.nodes.get(id);
+    if (kind === void 0) continue;
+    const fm = removed.has(id) ? fmA : fmB;
+    const meta = resolveMeta2(fm, kind, id);
+    const nodeLabel = meta?.label;
+    const wrappedLabel = nodeLabel !== void 0 && maxWidth !== void 0 ? wrapLabel(nodeLabel, maxWidth) : nodeLabel;
+    const label = wrappedLabel ? `${id}
+${wrappedLabel}` : id;
+    const shape = kind === "process" ? "ellipse" : "box";
+    const minWidth = calcMinWidth(label);
+    let styleAttrs;
+    if (added.has(id)) {
+      styleAttrs = 'style="filled", fillcolor="#c3e6cb", color="#28a745"';
+    } else if (removed.has(id)) {
+      styleAttrs = 'style="filled", fillcolor="#f5c6cb", color="#dc3545"';
+    } else if (changed.has(id)) {
+      styleAttrs = 'style="filled", fillcolor="#ffeeba", color="#e0a800"';
+    } else {
+      styleAttrs = 'style="filled", fillcolor="#f5f5f5", color="#bbbbbb", fontcolor="#777777"';
+    }
+    const attrs = [`shape=${shape}`, `label=${quote(label)}`];
+    if (minWidth !== void 0) attrs.push(`width=${minWidth.toFixed(2)}`);
+    attrs.push(styleAttrs);
+    lines.push(`  ${quote(id)} [${attrs.join(", ")}];`);
+  }
+  if (visiblePrimaryEdges.length > 0) {
+    lines.push("");
+    for (const [, val] of visiblePrimaryEdges) {
+      if (val.status === "added") {
+        lines.push(
+          `  ${quote(val.from)} -> ${quote(val.to)} [color="#28a745"];`
+        );
+      } else {
+        lines.push(
+          `  ${quote(val.from)} -> ${quote(val.to)} [color="#dc3545", style=dashed];`
+        );
+      }
+    }
+  }
+  if (visibleFeedbackEdges.length > 0) {
+    if (visiblePrimaryEdges.length === 0) lines.push("");
+    for (const [, val] of visibleFeedbackEdges) {
+      if (val.status === "added") {
+        lines.push(
+          `  ${quote(val.artifact)} -> ${quote(val.process)} [style=dashed, color="#28a745", constraint=false];`
+        );
+      } else {
+        lines.push(
+          `  ${quote(val.artifact)} -> ${quote(val.process)} [style=dashed, color="#dc3545", constraint=false];`
+        );
+      }
+    }
+  }
+  lines.push("}");
+  return `${lines.join("\n")}
+`;
+}
+async function svgToBinary(svg, format) {
+  const puppeteer = await import("puppeteer").catch(() => {
+    throw new Error(
+      `PDF/PNG export requires puppeteer. Install it with:
+  npm install puppeteer`
+    );
+  });
+  const viewBoxMatch = svg.match(/viewBox="([^"]+)"/);
+  const parts = viewBoxMatch?.[1]?.split(/\s+/).map(Number);
+  const width = parts?.[2] ?? 1200;
+  const height = parts?.[3] ?? 800;
+  const sandboxArgs = process.platform === "linux" ? ["--no-sandbox", "--disable-setuid-sandbox"] : [];
+  const browser = await puppeteer.default.launch({
+    headless: true,
+    args: sandboxArgs
+  });
+  try {
+    const page = await browser.newPage();
+    await page.setContent(
+      `<!DOCTYPE html><html><head><style>*{margin:0;padding:0;box-sizing:border-box}html,body{width:${width}px;height:${height}px;overflow:hidden}svg{display:block;width:${width}px;height:${height}px}</style></head><body>${svg}</body></html>`,
+      { waitUntil: "load" }
+    );
+    if (format === "pdf") {
+      return await page.pdf({
+        width: `${width}px`,
+        height: `${height}px`,
+        printBackground: true,
+        margin: { top: 0, right: 0, bottom: 0, left: 0 },
+        pageRanges: "1"
+      });
+    }
+    await page.setViewport({
+      width: Math.ceil(width),
+      height: Math.ceil(height),
+      deviceScaleFactor: 1
+    });
+    return await page.screenshot({ type: "png" });
+  } finally {
+    try {
+      await browser.close();
+    } catch {
+    }
+  }
+}
+export {
+  exportDiffDot,
+  exportDot,
+  svgToBinary
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pfdsl/graphviz-exporter",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@pfdsl/core": "0.0.1"
+  },
+  "peerDependencies": {
+    "puppeteer": ">=20.0.0"
+  },
+  "peerDependenciesMeta": {
+    "puppeteer": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "vitest": "^1.6.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}