@knowvah/dot-engine 0.1.0

package/src/render/svg-helpers.ts

@@ -0,0 +1,623 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * SVG renderer helper functions.
+ *
+ * All shape-emission logic lives here as top-level export functions so
+ * Lizard's TypeScript parser tracks function boundaries correctly.
+ * Lizard only resets its function-tracking on the export keyword;
+ * bare function declarations are silently absorbed into the preceding
+ * exported function's body count.
+ *
+ * Lizard parser bugs (affect this file):
+ * 1. Regex literal containing a double-quote char (e.g. /"/g) unbalances
+ *    its string-quote tracker.  Use new RegExp('"', 'g') instead.
+ * 2. Template literals containing ${...} interpolations confuse the parser
+ *    and cause following non-exported functions to be absorbed into the
+ *    preceding exported function's line-count.  Avoid ${...} template
+ *    literals in exported functions; use string concatenation or
+ *    job.write/printDouble sequences instead.
+ *
+ * @see plugin/core/gvrender_core_svg.c
+ */
+
+import type { Node } from '../model/node.js';
+import type { Edge } from '../model/edge.js';
+import type { Point, Bezier } from '../model/geom.js';
+import type { TextSpan } from '../common/emit-types.js';
+import { HTML_BF, HTML_IF, HTML_UL, HTML_SUP, HTML_SUB, HTML_S, HTML_OL } from '../common/emit-types.js';
+import { fontFamilyAttrs } from '../common/ps-fontalias.js';
+import type { RenderJob, ObjState } from '../gvc/job.js';
+import { colorPaint, colorOpacity, textFillAttrs } from './color-resolve.js';
+import { PenType, FillType } from '../gvc/context.js';
+import { emitLinearGradient, emitRadialGradient, gradientId } from './svg-gradient.js';
+import { transformPoint } from '../gvc/device.js';
+import { emitArrowOps } from './svg-arrow-ops.js';
+
+// ---------------------------------------------------------------------------
+// Module-level constants
+// ---------------------------------------------------------------------------
+
+const SVG_DASH_ARRAY = '5,2';
+const SVG_DOT_ARRAY = '1,5';
+const PENWIDTH_NORMAL = 1.0;
+const PENWIDTH_BOLD = 2.0;
+const PENWIDTH_THRESHOLD = 0.005;
+
+/**
+ * Padding (in graph units / points) added on all four sides of the bounding
+ * box, matching the C plugin descriptor `default_pad = 4.0`.
+ * @see plugin/core/gvrender_core_svg.c  (gvrender_features_t.default_pad)
+ */
+export const SVG_PAD = 4;
+
+/**
+ * Default graph-level margin (in points) when `margin=` is unset, matching
+ * the SVG plugin's `device_features_svg.default_margin` ({0,0}) — the
+ * `GVRENDER_PLUGIN` branch of `init_job_margin`'s fallback switch.
+ * @see plugin/core/gvrender_core_svg.c (device_features_svg.default_margin)
+ * @see lib/common/emit.c:3309-3331 init_job_margin
+ */
+export const SVG_MARGIN = 0;
+
+// XML escaping moved to ./xml-escape.ts (gv_xml_escape port); imported for
+// local use and re-exported so existing import sites keep resolving here.
+import { escapeXml, escapeXmlText, escapeXmlTitle } from './xml-escape.js';
+export { escapeXml, escapeXmlText, escapeXmlTitle };
+import { svgNodeId, svgEdgeId, svgNodeClass, svgEdgeClass } from './svg-id.js';
+import { orthoRoundedPolylines } from './svg-edge-ortho-radius.js';
+
+// ---------------------------------------------------------------------------
+// Color helpers
+// ---------------------------------------------------------------------------
+
+export function paintStr(obj: ObjState, useFill: boolean): string {
+  return colorPaint(useFill ? obj.fillColor : obj.penColor);
+}
+
+// ---------------------------------------------------------------------------
+// Style helpers
+// ---------------------------------------------------------------------------
+
+export function emitDash(job: RenderJob, pen: PenType): void {
+  if (pen === PenType.Dashed) {
+    job.write(' stroke-dasharray="' + SVG_DASH_ARRAY + '"');
+  } else if (pen === PenType.Dotted) {
+    job.write(' stroke-dasharray="' + SVG_DOT_ARRAY + '"');
+  }
+}
+
+export function emitPenWidth(job: RenderJob, pw: number): void {
+  if (Math.abs(pw - PENWIDTH_BOLD) < PENWIDTH_THRESHOLD) {
+    job.write(' stroke-width="' + String(PENWIDTH_BOLD) + '"');
+    return;
+  }
+  job.write(' stroke-width="');
+  job.printDouble(pw);
+  job.write('"');
+}
+
+/** Emit ` <attr>="<opacity>"` when the color carries partial alpha. */
+function emitOpacity(job: RenderJob, attr: string, color: ObjState['fillColor']): void {
+  const o = colorOpacity(color);
+  if (o !== null) job.write(' ' + attr + '="' + o + '"');
+}
+
+/**
+ * Emit fill/stroke style attributes in C's exact order: fill, fill-opacity,
+ * stroke, stroke-width, stroke-dasharray, stroke-opacity.
+ * @see plugin/core/gvrender_core_svg.c:165-213 svg_grstyle
+ */
+export function emitStyle(job: RenderJob, filled: boolean, gradFillUrl?: string): void {
+  const obj = job.obj;
+  const solidFill = obj !== null && filled;
+  const fill = gradFillUrl !== undefined
+    ? 'url(#' + gradFillUrl + ')'
+    : (solidFill ? paintStr(obj, true) : 'none');
+  job.write(' fill="' + fill + '"');
+  if (gradFillUrl === undefined && solidFill) emitOpacity(job, 'fill-opacity', obj.fillColor);
+  const stroke = obj !== null ? paintStr(obj, false) : 'black';
+  job.write(' stroke="' + stroke + '"');
+  if (obj === null) return;
+  const pw = obj.penWidth;
+  if (Math.abs(pw - PENWIDTH_NORMAL) >= PENWIDTH_THRESHOLD) {
+    emitPenWidth(job, pw);
+  }
+  emitDash(job, obj.pen);
+  emitOpacity(job, 'stroke-opacity', obj.penColor);
+}
+
+// ---------------------------------------------------------------------------
+// Point serialisation helpers
+// ---------------------------------------------------------------------------
+
+export function emitPoints(job: RenderJob, pts: Point[]): void {
+  for (let i = 0; i < pts.length; i++) {
+    const p = pts[i]!;
+    job.printDouble(p.x);
+    job.write(',');
+    job.printDouble(p.y);
+    if (i + 1 < pts.length) job.write(' ');
+  }
+}
+
+export function emitBezierPath(job: RenderJob, pts: Point[]): void {
+  for (let i = 0; i < pts.length; i++) {
+    const p = pts[i]!;
+    const c = i === 0 ? 'M' : (i === 1 ? 'C' : ' ');
+    job.write(c);
+    job.printDouble(p.x);
+    job.write(',');
+    job.printDouble(p.y);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Text alignment
+// ---------------------------------------------------------------------------
+
+export function textAnchor(just: 'l' | 'n' | 'r'): string {
+  if (just === 'l') return 'start';
+  if (just === 'r') return 'end';
+  return 'middle';
+}
+
+// ---------------------------------------------------------------------------
+// Graph open/close — moved to svg-graph.ts (file size cap); re-exported here
+// ---------------------------------------------------------------------------
+
+export {
+  emitSvgTag, emitGraphGroupOpen, emitGraphTitle,
+  emitGraphBackground, svgBeginGraph, svgEndGraph,
+  svgBeginPage, svgPageBackground, svgEndPage, svgBeginLayer, svgEndLayer,
+} from './svg-graph.js';
+
+// ---------------------------------------------------------------------------
+// Node / edge group wrappers
+// ---------------------------------------------------------------------------
+
+export function svgBeginNode(n: Node, job: RenderJob): void {
+  // Id from getObjId (DOT `id` attr / gid prefix / node<seq>); layer
+  // prefix/suffix are empty unless rendering layers (layerNum>1). The DOT
+  // `class` attr is appended to the SVG class string (svg_print_id_class).
+  // @see lib/common/emit.c:getObjId; plugin/core/gvrender_core_svg.c:svg_begin_node
+  // C's svg_print_id_class prints the assembled id through gvputs_xml, so the
+  // DOT `id` attr (and user-controlled layer names) are XML-escaped at emission.
+  job.write('<g id="' + escapeXmlTitle(job.idLayerPrefix() + svgNodeId(n, job) + job.idLayerSuffix())
+    + '" ' + svgNodeClass(n) + '>\n');
+  job.write('<title>' + escapeXmlTitle(n.name) + '</title>\n');
+}
+
+export function svgEndNode(job: RenderJob): void {
+  job.write('</g>\n');
+}
+
+/**
+ * XML-escape an edge title the way C's `gvputs_xml` does (gv_xml_escape with
+ * dash=1): `&`, `<`, `>`, and `-`→`&#45;`. The hyphen escaping is why dot emits
+ * `A&#45;&gt;B`, not `A-&gt;B`.
+ * @see lib/util/xml.c:xml_core (flags.dash)
+ */
+function escapeEdgeTitle(s: string): string {
+  // C routes edge titles through gvputs_xml ({dash, nbsp}, entity-aware '&');
+  // the previous hand-rolled version escaped '&' unconditionally and skipped
+  // the nbsp rule. @see lib/gvc/gvdevice.c:gvputs_xml
+  return escapeXmlTitle(s);
+}
+
+/**
+ * Begin an edge group + `<title>`. The title is `tail[:tport]<sep>head[:hport]`
+ * built raw, then escaped — mirroring C's `\E` substitution (`labels.c`) fed
+ * through `gvputs_xml`. The port string is the resolved port name
+ * (`ED_*_port(e).name`): a compass replaces a record field when both are given
+ * (`A:f0:n` → `A:n`), and the dash escapes to `&#45;`.
+ * @see lib/common/labels.c:strdup_and_subst_obj (case 'E')
+ * @see plugin/core/gvrender_core_svg.c:svg_begin_edge
+ */
+export function svgBeginEdge(e: Edge, job: RenderJob): void {
+  const sep = job.directed ? '->' : '--';
+  const tp = e.info.tail_port?.name;
+  const hp = e.info.head_port?.name;
+  const raw = e.tail.name + (tp ? ':' + tp : '')
+    + sep + e.head.name + (hp ? ':' + hp : '');
+  // Edges get the layer prefix only — no per-object suffix (svg_begin_edge
+  // passes idx=NULL, unlike svg_begin_node). DOT `id`/`class` attrs apply.
+  job.write('<g id="' + escapeXmlTitle(job.idLayerPrefix() + svgEdgeId(e, job))
+    + '" ' + svgEdgeClass(e) + '>\n');
+  job.write('<title>' + escapeEdgeTitle(raw) + '</title>\n');
+}
+
+export function svgEndEdge(job: RenderJob): void {
+  job.write('</g>\n');
+}
+
+// ---------------------------------------------------------------------------
+// Anchor helpers
+// ---------------------------------------------------------------------------
+
+export function emitAnchorAttrs(
+  href: string,
+  tooltip: string,
+  target: string,
+  job: RenderJob,
+): void {
+  if (href.length > 0) {
+    // C svg_begin_anchor writes xlink:href only.
+    // @see plugin/core/gvrender_core_svg.c:svg_begin_anchor
+    job.write(' xlink:href="' + escapeXml(href) + '"');
+  }
+  if (tooltip.length > 0) {
+    // C svg_begin_anchor uses flags {raw, dash, nbsp} for the tooltip.
+    // @see plugin/core/gvrender_core_svg.c:416
+    job.write(' xlink:title="' + escapeXmlText(tooltip) + '"');
+  }
+  if (target.length > 0) {
+    job.write(' target="' + escapeXml(target) + '"');
+  }
+}
+
+export function svgBeginAnchor(
+  href: string,
+  tooltip: string,
+  target: string,
+  id: string,
+  job: RenderJob,
+): void {
+  if (id.length > 0) {
+    // C routes anchor ids through gvputs_xml ({dash,nbsp}) like titles —
+    // an id derived from an edge name emits &#45; for hyphens (corpus 1880).
+    job.write('<g id="a_' + escapeXmlTitle(id) + '"><a');
+  } else {
+    job.write('<g><a');
+  }
+  emitAnchorAttrs(href, tooltip, target, job);
+  job.write('>\n');
+}
+
+export function svgEndAnchor(job: RenderJob): void {
+  job.write('</a>\n</g>\n');
+}
+
+// ---------------------------------------------------------------------------
+// Text span
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit a text span SVG element.
+ *
+ * pos.y is in Graphviz y-up space (same as pos.x for symmetry).
+ * C's svg_textspan writes `y = -(p.y + yoffset)` — negating the
+ * Graphviz coordinate and then adding the centerline offset.
+ * Match that behavior exactly.
+ *
+ * @see plugin/core/gvrender_core_svg.c:svg_textspan
+ */
+/**
+ * Build the text-decoration value string for HTML_UL / HTML_OL / HTML_S flags.
+ * Returns empty string when no decoration flags are set.
+ * @see plugin/core/gvrender_core_svg.c:svg_textspan lines 501-515
+ */
+function textDecorationValue(flags: number): string {
+  const parts: string[] = [];
+  if (flags & HTML_UL) parts.push('underline');
+  if (flags & HTML_OL) parts.push('overline');
+  if (flags & HTML_S)  parts.push('line-through');
+  return parts.join(',');
+}
+
+/**
+ * Emit the HTML-flag SVG attributes (bold/italic from markup, text-decoration,
+ * baseline-shift). bold/italic are skipped when the font alias already set them.
+ * @see plugin/core/gvrender_core_svg.c:496-516 svg_textspan flag block
+ */
+function emitFontAttrs(flags: number, job: RenderJob, alias: { weight: boolean; style: boolean }): void {
+  if (flags & HTML_BF && !alias.weight) job.write(' font-weight="bold"');
+  if (flags & HTML_IF && !alias.style) job.write(' font-style="italic"');
+  const dec = flags & (HTML_UL | HTML_OL | HTML_S)
+    ? textDecorationValue(flags) : '';
+  if (dec) job.write(' text-decoration="' + dec + '"');
+  if (flags & HTML_SUP) job.write(' baseline-shift="super"');
+  if (flags & HTML_SUB) job.write(' baseline-shift="sub"');
+}
+
+export function svgTextspan(pos: Point, span: TextSpan, job: RenderJob): void {
+  const anchor = textAnchor(span.just);
+  // C: p.y += yoffset_centerline; gvprintdouble(-p.y) → SVG y = -(y + offset)
+  const y = -(pos.y + span.yoffset_centerline);
+  job.write('<text xml:space="preserve" text-anchor="' + anchor + '"');
+  job.write(' x="');
+  job.printDouble(pos.x);
+  job.write('" y="');
+  job.printDouble(y);
+  job.write('"');
+  const ff = fontFamilyAttrs(span.fontName);
+  if (ff !== null) job.write(ff.attrs);
+  else job.write(' font-family="' + escapeXml(span.fontName ?? 'Times,serif') + '"');
+  emitFontAttrs(span.fontFlags, job, ff ?? { weight: false, style: false });
+  job.write(' font-size="' + span.fontSize.toFixed(2) + '"');
+  job.write(textFillAttrs(span.fontColor));
+  job.write('>' + escapeXmlText(span.str) + '</text>\n');
+}
+
+// ---------------------------------------------------------------------------
+// Shape emitters
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit `<defs>` gradient block for a filled shape; returns the gradient id
+ * to use as fill="url(#id)", or undefined for solid/none fills (AD2, AD3).
+ * pts must be in y-up (Graphviz) coordinate space.
+ * @see plugin/core/gvrender_core_svg.c:647-694 (gradient dispatch)
+ */
+export function emitGradientDefs(job: RenderJob, ptsYup: Point[], filled: boolean): string | undefined {
+  if (!filled) return undefined;
+  const obj = job.obj;
+  if (obj === null) return undefined;
+  if (obj.fill === FillType.Linear) {
+    const gid = gradientId(obj.id, 'l', job.linearGradId++);
+    emitLinearGradient(job, ptsYup, gid);
+    return gid;
+  }
+  if (obj.fill === FillType.Radial) {
+    const gid = gradientId(obj.id, 'r', job.radialGradId++);
+    emitRadialGradient(job, gid);
+    return gid;
+  }
+  return undefined;
+}
+export function svgEllipse(
+  center: Point,
+  rx: number,
+  ry: number,
+  filled: boolean,
+  job: RenderJob,
+): void {
+  const ptsUp = [{ x: center.x, y: -center.y }, { x: center.x + rx, y: -center.y + ry }];
+  const gradUrl = emitGradientDefs(job, ptsUp, filled);
+  job.write('<ellipse');
+  emitStyle(job, filled, gradUrl);
+  job.write(' cx="');
+  job.printDouble(center.x);
+  job.write('" cy="');
+  job.printDouble(center.y);
+  job.write('" rx="');
+  job.printDouble(rx);
+  job.write('" ry="');
+  job.printDouble(ry);
+  job.write('"/>\n');
+}
+export function svgPolygon(pts: Point[], filled: boolean, job: RenderJob): void {
+  const ptsUp = pts.map((p) => ({ x: p.x, y: -p.y }));
+  const gradUrl = emitGradientDefs(job, ptsUp, filled);
+  job.write('<polygon');
+  emitStyle(job, filled, gradUrl);
+  job.write(' points="');
+  emitPoints(job, pts);
+  if (pts.length > 0) {
+    // Repeat first point — Adobe SVG compatibility
+    // @see plugin/core/gvrender_core_svg.c:svg_polygon
+    const p0 = pts[0]!;
+    job.write(' ');
+    job.printDouble(p0.x);
+    job.write(',');
+    job.printDouble(p0.y);
+  }
+  job.write('"/>\n');
+}
+export function svgBezier(pts: Point[], filled: boolean, job: RenderJob): void {
+  const ptsUp = pts.map((p) => ({ x: p.x, y: -p.y }));
+  const gradUrl = emitGradientDefs(job, ptsUp, filled);
+  job.write('<path');
+  emitStyle(job, filled, gradUrl);
+  job.write(' d="');
+  emitBezierPath(job, pts);
+  job.write('"/>\n');
+}
+export function svgPolyline(pts: Point[], job: RenderJob): void {
+  job.write('<polyline');
+  emitStyle(job, false);
+  job.write(' points="');
+  emitPoints(job, pts);
+  job.write('"/>\n');
+}
+
+export function svgComment(text: string, job: RenderJob): void {
+  job.write('<!-- ' + escapeXml(text) + ' -->\n');
+}
+
+// ---------------------------------------------------------------------------
+// Edge graphics — path and arrowhead polygon
+// @see plugin/core/gvrender_core_svg.c:svg_bzptarray + svg_polygon (arrow)
+// @see lib/common/emit.c:emit_edge_graphics:2350 (color/penwidth flow)
+// ---------------------------------------------------------------------------
+
+/**
+ * Emit Bezier edge path with style from job.obj (AD1: no ad-hoc attr reads).
+ * Attribute order: fill="none" stroke="X" [stroke-width] [stroke-dasharray] d="..."
+ * @see plugin/core/gvrender_core_svg.c:svg_bzptarray
+ * @see lib/common/emit.c:emit_edge_graphics:2368 (late_string color)
+ */
+export function svgEdgePath(e: Edge, job: RenderJob): void {
+  const spl = e.info.spl;
+  if (spl === undefined || spl.size === 0) return;
+  const obj = job.obj;
+  const stroke = obj !== null ? paintStr(obj, false) : 'black';
+  const st = { tailDone: false, headDone: false };
+  for (let si = 0; si < spl.size; si++) {
+    const bz = spl.list[si] as Bezier | undefined;
+    if (bz === undefined || bz.size < 4) continue;
+    emitOneBezierPath(bz, stroke, job);
+    // C draws each bezier's arrowheads immediately after its curve, inside
+    // the per-bezier loop (bz.sflag → tail arrow, bz.eflag → head arrow) —
+    // for a multi-bezier concentrate spline the arrow interleaves BETWEEN
+    // the paths (b69 g[84]: [path, arrow-polygon, path]).
+    // @see lib/common/emit.c:2668-2676 (arrow_gen after gvrender_beziercurve)
+    emitBezierArrows(e, bz, job, st);
+  }
+  emitRemainingArrows(e, job, st);
+}
+
+/** Per-bezier arrow emission (C's in-loop arrow_gen calls). */
+function emitBezierArrows(
+  e: Edge, bz: Bezier, job: RenderJob,
+  st: { tailDone: boolean; headDone: boolean },
+): void {
+  const obj = job.obj;
+  const penColor = obj !== null ? paintStr(obj, false) : 'black';
+  const opacity = obj !== null ? colorOpacity(obj.penColor) : null;
+  const pw = obj !== null ? obj.penWidth : 1.0;
+  if (bz.sflag !== 0 && !st.tailDone && e.info.tailArrowOps?.length) {
+    emitArrowOps(e.info.tailArrowOps, penColor, job, pw, opacity);
+    st.tailDone = true;
+  }
+  if (bz.eflag !== 0 && !st.headDone && e.info.headArrowOps?.length) {
+    emitArrowOps(e.info.headArrowOps, penColor, job, pw, opacity);
+    st.headDone = true;
+  }
+}
+
+/**
+ * Arrow ops whose bezier carried no s/eflag (a port-model seam: ops are stored
+ * per edge end, flags per bezier). C cannot reach this state — an arrow is only
+ * generated where a flag is set — so this emits at the old position (group
+ * end) purely to keep behavior identical if a router ever stashes ops without
+ * setting the flag.
+ */
+function emitRemainingArrows(
+  e: Edge, job: RenderJob,
+  st: { tailDone: boolean; headDone: boolean },
+): void {
+  const obj = job.obj;
+  const penColor = obj !== null ? paintStr(obj, false) : 'black';
+  const opacity = obj !== null ? colorOpacity(obj.penColor) : null;
+  const pw = obj !== null ? obj.penWidth : 1.0;
+  if (!st.tailDone && e.info.tailArrowOps?.length) {
+    emitArrowOps(e.info.tailArrowOps, penColor, job, pw, opacity);
+  }
+  if (!st.headDone && e.info.headArrowOps?.length) {
+    emitArrowOps(e.info.headArrowOps, penColor, job, pw, opacity);
+  }
+}
+
+/** Emit one bezier as a `<path d="M…C…">`. Extracted from svgEdgePath so the
+ *  ortho-rounded path can share the no-corner fallback. */
+function emitOneBezierPath(bz: Bezier, stroke: string, job: RenderJob): void {
+  const obj = job.obj;
+  // Emit exactly bz.size points: list is over-allocated (calloc'd) to the
+  // pre-clip length; the zeroed tail is never emitted. @see splines.c:new_spline
+  const pts = bz.list.slice(0, bz.size).map((p) => transformPoint(p, job));
+  job.write('<path fill="none" stroke="' + stroke + '"');
+  if (obj !== null && Math.abs(obj.penWidth - PENWIDTH_NORMAL) >= PENWIDTH_THRESHOLD) {
+    emitPenWidth(job, obj.penWidth);
+  }
+  if (obj !== null) emitDash(job, obj.pen);
+  // C svg_grstyle emits stroke-opacity (after stroke-width/dasharray) for an
+  // RGBA pen color with partial alpha (edge color="#rrggbbaa").
+  // @see plugin/core/gvrender_core_svg.c:207-210
+  if (obj !== null) emitOpacity(job, 'stroke-opacity', obj.penColor);
+  job.write(' d="');
+  emitBezierPath(job, pts);
+  job.write('"/>\n');
+}
+
+/**
+ * If edge `e` should render with rounded ortho corners, return its corner
+ * radius; else null. Mirrors emit.c:2554-2581: graph `splines==ortho`, then
+ * `radius>0` (explicit, overrides style) or `style=rounded` → default radius
+ * `max(12, penwidth*8)`.
+ * @see lib/common/emit.c (is_ortho / want_rounded / radius)
+ */
+export function orthoRoundedRadius(e: Edge, job: RenderJob): number | null {
+  if (e.head.root.attrs.get('splines') !== 'ortho') return null;
+  let wantRounded = false;
+  let radius = 0;
+  const style = e.attrs.get('style');
+  if (style !== undefined &&
+      style.split(',').map((s) => s.trim()).includes('rounded')) {
+    wantRounded = true;
+  }
+  const radiusAttr = e.attrs.get('radius');
+  if (radiusAttr !== undefined && radiusAttr.length > 0) {
+    radius = parseFloat(radiusAttr) || 0; // atof: non-numeric → 0
+    wantRounded = radius > 0;             // explicit radius overrides style
+  }
+  if (wantRounded && radius === 0) {
+    const pw = job.obj !== null ? job.obj.penWidth : 1.0;
+    radius = Math.max(12.0, pw * 8.0);
+  }
+  return wantRounded && radius > 0 ? radius : null;
+}
+
+/**
+ * Emit an ortho edge whose corners are rounded (`splines=ortho` and `radius>0`
+ * or `style=rounded`): straight `<polyline>` segments between truncated corners
+ * plus an arc `<polyline>` per corner. Per-bezier fallback to the bezier `<path>`
+ * when a bezier has no orthogonal corner. @see lib/common/emit.c:2583-2666
+ */
+export function svgEdgePathOrthoRounded(e: Edge, radius: number, job: RenderJob): void {
+  const spl = e.info.spl;
+  if (spl === undefined || spl.size === 0) return;
+  const obj = job.obj;
+  const stroke = obj !== null ? paintStr(obj, false) : 'black';
+  for (let si = 0; si < spl.size; si++) {
+    const bz = spl.list[si] as Bezier | undefined;
+    if (bz === undefined || bz.size < 4) continue;
+    const internal = bz.list.slice(0, bz.size);
+    const polys = orthoRoundedPolylines(internal, radius);
+    if (polys.length === 0) {
+      emitOneBezierPath(bz, stroke, job); // no corner → bezier fallback
+    } else {
+      for (const poly of polys) {
+        svgPolyline(poly.map((p) => transformPoint(p, job)), job);
+      }
+    }
+  }
+}
+
+/**
+ * Emit one arrowhead polygon with pen color from job.obj and Adobe first-point
+ * repetition.  Exported so Lizard resets its line counter here (parser note above).
+ * @see plugin/core/gvrender_core_svg.c:svg_polygon (arrowhead case)
+ */
+export function emitArrowPolygon(rawPts: Point[], penColor: string, job: RenderJob, pw: number): void {
+  const pts = rawPts.map((p) => transformPoint(p, job));
+  job.write('<polygon fill="' + penColor + '" stroke="' + penColor + '"');
+  if (Math.abs(pw - PENWIDTH_NORMAL) >= PENWIDTH_THRESHOLD) {
+    emitPenWidth(job, pw);
+  }
+  job.write(' points="');
+  emitPoints(job, pts);
+  if (pts.length > 0) {
+    const p0 = pts[0]!;
+    job.write(' ');
+    job.printDouble(p0.x);
+    job.write(',');
+    job.printDouble(p0.y);
+  }
+  job.write('"/>\n');
+}
+
+/**
+ * Emit arrowhead polygon(s) for a routed edge (tail first, then head).
+ * Arrow fill and stroke use the edge pen color from job.obj (AD1).
+ * @see plugin/core/gvrender_core_svg.c:svg_polygon (arrowhead case)
+ * @see lib/common/arrows.c:arrow_type_normal
+ */
+export function svgArrowPolygons(e: Edge, job: RenderJob): void {
+  const obj = job.obj;
+  const penColor = obj !== null ? paintStr(obj, false) : 'black';
+  const opacity = obj !== null ? colorOpacity(obj.penColor) : null;
+  const pw = obj !== null ? obj.penWidth : 1.0;
+  const tailOps = e.info.tailArrowOps;
+  if (tailOps?.length) emitArrowOps(tailOps, penColor, job, pw, opacity);
+  const headOps = e.info.headArrowOps;
+  if (headOps?.length) emitArrowOps(headOps, penColor, job, pw, opacity);
+}
+
+// ---------------------------------------------------------------------------
+// Parallel multi-color edge emission — moved to svg-parallel-edge.ts (file-
+// size cap, AD5).  Re-exported here so callers import from one place.
+// ---------------------------------------------------------------------------
+
+export { emitParallelEdgePaths } from './svg-parallel-edge.js';
+export type { ParallelEdgeResult } from './svg-parallel-edge.js';