@knowvah/dot-engine 2.6.0 → 2.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowvah/dot-engine",
-  "version": "2.6.0",
+  "version": "2.6.2",
   "description": "Faithful TypeScript port of Graphviz (dot, neato, fdp, sfdp, circo, twopi, osage, patchwork) — no C: no native binary, no WASM. Oracle-verified against the C implementation, runs in the browser.",
   "keywords": [
     "graphviz",
@@ -100,7 +100,7 @@
   },
   "devDependencies": {
     "@fontsource/jetbrains-mono": "^5.3.0",
-    "@hpcc-js/wasm-graphviz": "1.28.0",
+    "@hpcc-js/wasm-graphviz": "1.29.2",
     "@knowvah/theme": "0.3.0",
     "@knowvah/vitepress-plugin-dot": "^3.0.1",
     "@semantic-release/commit-analyzer": "^13.0.1",

package/src/common/bezier-arrows.ts

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Which precomputed arrow ops to draw for each bezier of an edge.
+//
+// C draws arrows at render time inside emit_edge_graphics' per-bezier loop:
+// every bezier whose sflag/eflag is set gets its own arrow_gen call. The port
+// computes arrows at clip time (arrowhead-geometry ADR-2) and keeps one op list
+// per edge end (`e.info.tailArrowOps` / `headArrowOps`) — enough while at most
+// one bezier carries each flag, which is every spline except neato's
+// multispline fallback (neatosplines.c:683-701: makeMultiSpline fails partway,
+// then makeSpline appends a second flagged bezier). For that case each bezier
+// also carries its own ops (`Bezier.sArrowOps` / `eArrowOps`, set by
+// clipAndInstall), and these helpers hand the emitters one list per bezier.
+// With at most one flagged bezier per end, the edge-level ops stay the source:
+// dot's swap, flat-edge and compound passes rewrite only those.
+//
+// @see lib/common/emit.c:emit_edge_graphics (2669-2675)
+
+import type { Edge } from '../model/edge.js';
+import type { Bezier } from '../model/geom.js';
+import type { ArrowDrawOp } from './arrows-types.js';
+
+/** Edge end: `tail` pairs with a bezier's sflag/sp, `head` with eflag/ep. */
+export type ArrowEnd = 'head' | 'tail';
+
+const flagOf = (bz: Bezier, end: ArrowEnd): number => (end === 'head' ? bz.eflag : bz.sflag);
+const ownOps = (bz: Bezier, end: ArrowEnd): ArrowDrawOp[] | undefined =>
+  (end === 'head' ? bz.eArrowOps : bz.sArrowOps);
+const edgeOps = (e: Edge, end: ArrowEnd): ArrowDrawOp[] | undefined =>
+  (end === 'head' ? e.info.headArrowOps : e.info.tailArrowOps);
+
+function flaggedBeziers(e: Edge, end: ArrowEnd): Bezier[] {
+  const list = (e.info.spl?.list ?? []) as (Bezier | undefined)[];
+  return list.filter((bz): bz is Bezier => bz !== undefined && flagOf(bz, end) !== 0);
+}
+
+/** Two or more beziers carry `end`'s flag: C draws an arrow for each. */
+function multiFlagged(e: Edge, end: ArrowEnd): boolean {
+  return flaggedBeziers(e, end).length > 1;
+}
+
+/**
+ * The ops C's per-bezier loop draws right after `bz` for `end`, when the edge
+ * has several beziers flagged at that end; undefined otherwise (the caller's
+ * edge-level path applies).
+ */
+export function bezierEndOps(e: Edge, bz: Bezier, end: ArrowEnd): ArrowDrawOp[] | undefined {
+  if (flagOf(bz, end) === 0 || !multiFlagged(e, end)) return undefined;
+  return ownOps(bz, end) ?? edgeOps(e, end);
+}
+
+/** Every arrow to draw for `end`, one op list per arrow, in bezier order. */
+export function endArrowOps(e: Edge, end: ArrowEnd): ArrowDrawOp[][] {
+  const lists = multiFlagged(e, end)
+    ? flaggedBeziers(e, end).map((bz) => ownOps(bz, end) ?? edgeOps(e, end))
+    : [edgeOps(e, end)];
+  return lists.filter((ops): ops is ArrowDrawOp[] => ops !== undefined && ops.length > 0);
+}

package/src/common/pointset.ts

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Set of points, compared exactly on their double coordinates.
+ *
+ * C keeps the points in an ordered cdt dictionary (`Dtoset`) under `cmppair`:
+ * x first, then y, plain double `<`/`>`, so -0 and 0 are one key. Here the
+ * dictionary is a two-level `Map` keyed on the coordinates themselves. Map
+ * keys use SameValueZero, which also makes -0 and 0 one key. A lookup
+ * allocates nothing; packing calls it once per cell per candidate position.
+ *
+ * @see lib/common/pointset.c
+ */
+
+import type { Point } from '../model/geom.js';
+
+/** @see lib/common/pointset.c:cmppair */
+function cmpPair(a: Point, b: Point): number {
+  if (a.x > b.x) return 1;
+  if (a.x < b.x) return -1;
+  if (a.y > b.y) return 1;
+  if (a.y < b.y) return -1;
+  return 0;
+}
+
+/** @see lib/common/pointset.h:PointSet */
+export class PointSet {
+  private readonly byX = new Map<number, Map<number, Point>>();
+  private n = 0;
+
+  /**
+   * Insert (x, y). A duplicate keeps the point inserted first, as `dtinsert`
+   * returns the existing object and the new one is freed.
+   * @see lib/common/pointset.c:addPS
+   */
+  addPS(x: number, y: number): void {
+    let col = this.byX.get(x);
+    if (col === undefined) {
+      col = new Map();
+      this.byX.set(x, col);
+    }
+    if (col.has(y)) return;
+    col.set(y, { x, y });
+    this.n++;
+  }
+
+  /** @see lib/common/pointset.c:inPS */
+  inPS(pt: Point): boolean {
+    return this.byX.get(pt.x)?.has(pt.y) ?? false;
+  }
+
+  /** @see lib/common/pointset.c:isInPS */
+  isInPS(x: number, y: number): boolean {
+    return this.byX.get(x)?.has(y) ?? false;
+  }
+
+  /** @see lib/common/pointset.c:sizeOf */
+  sizeOf(): number {
+    return this.n;
+  }
+
+  /**
+   * The points in dictionary order (`dtflatten` walks the ordered set).
+   * @see lib/common/pointset.c:pointsOf
+   */
+  pointsOf(): Point[] {
+    const pts: Point[] = [];
+    for (const col of this.byX.values()) {
+      for (const p of col.values()) pts.push({ x: p.x, y: p.y });
+    }
+    return pts.sort(cmpPair);
+  }
+}

package/src/common/postproc.ts

@@ -16,7 +16,7 @@
  */
 
 import type { Graph } from '../model/graph.js';
-import type { Point, Box } from '../model/geom.js';
+import type { Point, Box, Bezier } from '../model/geom.js';
 import { ccwrotatepf } from '../model/geom.js';
 import type { ArrowDrawOp } from './arrows-types.js';
 import { mapArrowOpPoints } from './arrows-shapes-util.js';
@@ -39,9 +39,12 @@ const IGNORED_EDGE = 6;
 let Rankdir = 0;
 let Offset: Point = { x: 0, y: 0 };
 
+/** The bezier fields map_edge reads/writes. */
+type MappedBezier = Pick<Bezier, 'list' | 'sflag' | 'eflag' | 'sp' | 'ep' | 'sArrowOps' | 'eArrowOps'>;
+
 /** The edge-info shape map_edge reads/writes (spline, labels, arrow ops). */
 interface EdgeArrowInfo {
-  spl?: { list: Array<{ list: Point[]; sflag: number; eflag: number; sp: Point; ep: Point }> };
+  spl?: { list: MappedBezier[] };
   label?: unknown;
   xlabel?: unknown;
   head_label?: unknown;
@@ -116,17 +119,6 @@ function mapArrowOps(ops: ArrowDrawOp[] | undefined): ArrowDrawOp[] | undefined
   });
 }
 
-/** The edge-info shape map_edge reads/writes (spline, labels, arrow ops). */
-interface EdgeArrowInfo {
-  spl?: { list: Array<{ list: Point[]; sflag: number; eflag: number; sp: Point; ep: Point }> };
-  label?: unknown;
-  xlabel?: unknown;
-  head_label?: unknown;
-  tail_label?: unknown;
-  headArrowOps?: ArrowDrawOp[];
-  tailArrowOps?: ArrowDrawOp[];
-}
-
 /**
  * Map spline control points, label positions, and pre-computed arrow draw-ops
  * for one edge. The C port regenerates arrowheads at render time from the
@@ -145,6 +137,10 @@ function mapEdge(e: { info: EdgeArrowInfo }): void {
   // Rotate pre-computed arrowhead draw-ops (TS-only: C computes at render time).
   e.info.headArrowOps = mapArrowOps(e.info.headArrowOps);
   e.info.tailArrowOps = mapArrowOps(e.info.tailArrowOps);
+  for (const bz of spl.list) {
+    if (bz.sArrowOps) bz.sArrowOps = mapArrowOps(bz.sArrowOps);
+    if (bz.eArrowOps) bz.eArrowOps = mapArrowOps(bz.eArrowOps);
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/common/splines-clip.ts

@@ -258,20 +258,20 @@ class SplineClipHelper {
       if (sflag || eflag) {
         SplineClipHelper.arrowOrthoClip(
           orig, ps, bounds.start, bounds.end, newspl, sflag, eflag);
-        if (sflag) SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true, startEnd);
-        if (eflag) SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
+        if (sflag) SplineClipHelper.stashArrow(orig, newspl, newspl.sp, ps[bounds.start]!, true, startEnd);
+        if (eflag) SplineClipHelper.stashArrow(orig, newspl, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
       }
       return;
     }
     if (sflag) {
       bounds.start = SplineClipHelper.arrowStartClip(
         orig, ps, bounds.start, bounds.end, newspl, sflag, startEnd);
-      SplineClipHelper.stashArrow(orig, newspl.sp, ps[bounds.start]!, true, startEnd);
+      SplineClipHelper.stashArrow(orig, newspl, newspl.sp, ps[bounds.start]!, true, startEnd);
     }
     if (eflag) {
       bounds.end = SplineClipHelper.arrowEndClip(
         orig, ps, bounds.start, bounds.end, newspl, eflag, endEnd);
-      SplineClipHelper.stashArrow(orig, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
+      SplineClipHelper.stashArrow(orig, newspl, newspl.ep, ps[bounds.end + 3]!, false, endEnd);
     }
   }
 
@@ -336,15 +336,19 @@ class SplineClipHelper {
     }
   }
 
-  /** Record an arrow polygon on the edge for svgArrowPolygons. */
+  /**
+   * Record an arrow on the edge end and on the bezier being installed. The
+   * edge slot holds the latest arrow; the bezier keeps its own, since C draws
+   * one per flagged bezier (see common/bezier-arrows.ts).
+   */
   static stashArrow(
-    e: Edge, tip: Point, base: Point, isTail: boolean, attrEnd?: 'head' | 'tail',
+    e: Edge, bz: Bezier, tip: Point, base: Point, isTail: boolean, attrEnd?: 'head' | 'tail',
   ): void {
     const dir = { x: base.x - tip.x, y: base.y - tip.y };
     const end = attrEnd ?? (isTail ? 'tail' : 'head');
     const ops = arrowDrawOpsForEnd(e, end, tip, dir, SplineClipHelper.renderPenwidth(e));
-    if (isTail) e.info.tailArrowOps = ops;
-    else e.info.headArrowOps = ops;
+    if (isTail) { e.info.tailArrowOps = ops; bz.sArrowOps = ops; }
+    else { e.info.headArrowOps = ops; bz.eArrowOps = ops; }
   }
 
   static clipSide(n: Node, box: Box | null, ps: Point[], pn: number, tail: boolean): number {

package/src/layout/dot/splines.ts

@@ -290,6 +290,10 @@ export function swapBezier(b: Bezier): void {
   }
   const sf = b.sflag; b.sflag = b.eflag; b.eflag = sf;
   const sp = b.sp; b.sp = b.ep; b.ep = sp;
+  // TS-only per-bezier arrow ops stay paired with their flag.
+  if (b.sArrowOps !== undefined || b.eArrowOps !== undefined) {
+    const so = b.sArrowOps; b.sArrowOps = b.eArrowOps; b.eArrowOps = so;
+  }
 }
 
 /** Reverse the list of beziers in a spline and swap each bezier. */

package/src/layout/pack/index.ts

@@ -313,6 +313,10 @@ export function shiftEdgePoints(e: Edge, dx: number, dy: number): void {
     ops?.map((op) => mapArrowOpPoints(op, (p) => ({ x: p.x + dx, y: p.y + dy })));
   e.info.headArrowOps = shiftOps(e.info.headArrowOps);
   e.info.tailArrowOps = shiftOps(e.info.tailArrowOps);
+  for (const bz of spl.list) {
+    if (bz.sArrowOps) bz.sArrowOps = shiftOps(bz.sArrowOps);
+    if (bz.eArrowOps) bz.eArrowOps = shiftOps(bz.eArrowOps);
+  }
 }
 
 export function shiftOneGraph(g: Graph, dx: number, dy: number): void {

package/src/layout/pack/poly-place.ts

@@ -21,6 +21,7 @@ import { PackMode } from './types.js';
 import { cround } from '../../common/arith.js';
 import { d2i } from '../../util/math.js';
 import { gvQsort } from '../../util/bsd-qsort.js';
+import { PointSet } from '../../common/pointset.js';
 
 /** Max. avg. polyomino size. @see lib/pack/pack.c:C */
 const C_AVG = 100;
@@ -40,23 +41,6 @@ function cell(p: Point, s: number): Point {
   return { x: cval(p.x, s), y: cval(p.y, s) };
 }
 
-/** Integer point set. @see lib/common/pointset.c */
-class PointSet {
-  private readonly m = new Map<string, Point>();
-  add(x: number, y: number): void {
-    this.m.set(`${x},${y}`, { x, y });
-  }
-  has(p: Point): boolean {
-    return this.m.has(`${p.x},${p.y}`);
-  }
-  points(): Point[] {
-    return [...this.m.values()];
-  }
-  get size(): number {
-    return this.m.size;
-  }
-}
-
 /** Polyomino info for one graph. @see lib/pack/pack.c:ginfo */
 interface GInfo {
   perim: number;
@@ -96,7 +80,7 @@ interface LineState {
 function lineXDominant(st: LineState, ps: PointSet): void {
   let d = st.ay - (st.ax >> 1);
   for (;;) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.x === st.x2) return;
     if (d >= 0) { st.y += st.sy; d -= st.ax; }
     st.x += st.sx;
@@ -108,7 +92,7 @@ function lineXDominant(st: LineState, ps: PointSet): void {
 function lineYDominant(st: LineState, ps: PointSet): void {
   let d = st.ax - (st.ay >> 1);
   for (;;) {
-    ps.add(st.x, st.y);
+    ps.addPS(st.x, st.y);
     if (st.y === st.y2) return;
     if (d >= 0) { st.x += st.sx; d -= st.ay; }
     st.y += st.sy;
@@ -136,7 +120,7 @@ function fillLine(p: Point, q: Point, ps: PointSet): void {
 /** Mark all cells in the inclusive cell-rect [LL, UR]. */
 function fillRect(LL: Point, UR: Point, ps: PointSet): void {
   for (let x = LL.x; x <= UR.x; x++) {
-    for (let y = LL.y; y <= UR.y; y++) ps.add(x, y);
+    for (let y = LL.y; y <= UR.y; y++) ps.addPS(x, y);
   }
 }
 
@@ -208,7 +192,7 @@ function genBox(bb0: Box, ssize: number, margin: number, center: Point): GInfo {
   const UR = roundedCell({ x: center.x + bbW + margin, y: center.y + bbH + margin }, ssize);
   fillRect(LL, UR, ps);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     perim: grid(bb0.ur.x - bb0.ll.x + 2 * margin, ssize)
       + grid(bb0.ur.y - bb0.ll.y + 2 * margin, ssize),
     index: 0,
@@ -266,7 +250,7 @@ function genPoly(
   };
   for (const n of g.nodes.values()) coverNode(n, ctx);
   return {
-    cells: ps.points(),
+    cells: ps.pointsOf(),
     perim: grid(bb.ur.x - bb.ll.x + 2 * pinfo.margin, ssize)
       + grid(bb.ur.y - bb.ll.y + 2 * pinfo.margin, ssize),
     index: 0,
@@ -289,7 +273,7 @@ interface PlaceCtx {
 
 function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): boolean {
   for (const c of info.cells) {
-    if (ctx.ps.has({ x: c.x + x, y: c.y + y })) return false;
+    if (ctx.ps.isInPS(c.x + x, c.y + y)) return false;
   }
   const bb = ctx.bbs[info.index]!;
   const LL = { x: cround(bb.ll.x), y: cround(bb.ll.y) };
@@ -297,30 +281,44 @@ function fits(x: number, y: number, info: GInfo, ctx: PlaceCtx): boolean {
   // is widened to double (objdump of libgvc `_fits`). Matters only once
   // computeStep has saturated at INT_MAX.
   ctx.places[info.index] = { x: Math.imul(ctx.step, x) - LL.x, y: Math.imul(ctx.step, y) - LL.y };
-  for (const c of info.cells) ctx.ps.add(c.x + x, c.y + y);
+  for (const c of info.cells) ctx.ps.addPS(c.x + x, c.y + y);
   return true;
 }
 
-/** Ring candidates for wide graphs (W >= H). @see pack.c:placeGraph */
-function* ringWide(bnd: number): Generator<[number, number]> {
-  let x = 0;
-  let y = -bnd;
-  for (; x < bnd; x++) yield [x, y];
-  for (; y < bnd; y++) yield [x, y];
-  for (; x > -bnd; x--) yield [x, y];
-  for (; y > -bnd; y--) yield [x, y];
-  for (; x < 0; x++) yield [x, y];
+/** Ring cursor, shared by the legs of one ring as C shares its x and y. */
+interface Cursor {
+  x: number;
+  y: number;
+}
+
+/**
+ * One straight leg of a ring: step (dx, dy) from the cursor until the moving
+ * coordinate reaches `end`, trying each cell. Every leg starts on the
+ * `end` side's integer lattice with a unit step, so `!== end` stops where C's
+ * `<`/`>` bound does.
+ * @see pack.c:placeGraph (one of the five loops per ring)
+ */
+function leg(c: Cursor, dx: number, dy: number, end: number, info: GInfo, ctx: PlaceCtx): boolean {
+  for (; (dx !== 0 ? c.x : c.y) !== end; c.x += dx, c.y += dy) {
+    if (fits(c.x, c.y, info, ctx)) return true;
+  }
+  return false;
 }
 
-/** Ring candidates for tall graphs (W < H). @see pack.c:placeGraph */
-function* ringTall(bnd: number): Generator<[number, number]> {
-  let y = 0;
-  let x = -bnd;
-  for (; y > -bnd; y--) yield [x, y];
-  for (; x < bnd; x++) yield [x, y];
-  for (; y < bnd; y++) yield [x, y];
-  for (; x > -bnd; x--) yield [x, y];
-  for (; y > 0; y--) yield [x, y];
+/** Ring `bnd` for wide graphs (W >= H). @see pack.c:placeGraph */
+function ringWide(bnd: number, info: GInfo, ctx: PlaceCtx): boolean {
+  const c = { x: 0, y: -bnd };
+  return leg(c, 1, 0, bnd, info, ctx) || leg(c, 0, 1, bnd, info, ctx)
+    || leg(c, -1, 0, -bnd, info, ctx) || leg(c, 0, -1, -bnd, info, ctx)
+    || leg(c, 1, 0, 0, info, ctx);
+}
+
+/** Ring `bnd` for tall graphs (W < H). @see pack.c:placeGraph */
+function ringTall(bnd: number, info: GInfo, ctx: PlaceCtx): boolean {
+  const c = { x: -bnd, y: 0 };
+  return leg(c, 0, -1, -bnd, info, ctx) || leg(c, 1, 0, bnd, info, ctx)
+    || leg(c, 0, 1, bnd, info, ctx) || leg(c, -1, 0, -bnd, info, ctx)
+    || leg(c, 0, -1, 0, info, ctx);
 }
 
 /**
@@ -331,7 +329,7 @@ function* ringTall(bnd: number): Generator<[number, number]> {
  */
 function placeFixed(info: GInfo, ctx: PlaceCtx, center: Point): void {
   ctx.places[info.index] = { x: -center.x, y: -center.y };
-  for (const c of info.cells) ctx.ps.add(c.x, c.y);
+  for (const c of info.cells) ctx.ps.addPS(c.x, c.y);
 }
 
 /**
@@ -349,10 +347,7 @@ function placeGraph(i: number, info: GInfo, ctx: PlaceCtx): void {
   if (fits(0, 0, info, ctx)) return;
   const wide = Math.ceil(bb.ur.x - bb.ll.x) >= Math.ceil(bb.ur.y - bb.ll.y);
   for (let bnd = 1; ; bnd++) {
-    const ring = wide ? ringWide(bnd) : ringTall(bnd);
-    for (const [x, y] of ring) {
-      if (fits(x, y, info, ctx)) return;
-    }
+    if (wide ? ringWide(bnd, info, ctx) : ringTall(bnd, info, ctx)) return;
   }
 }
 

package/src/model/geom.ts

@@ -8,6 +8,8 @@
  * @see lib/common/const.h
  */
 
+import type { ArrowDrawOp } from '../common/arrows-types.js';
+
 // ---------------------------------------------------------------------------
 // Points
 // ---------------------------------------------------------------------------
@@ -56,6 +58,14 @@ export type Bezier = {
   sp: Point;
   /** @see lib/common/types.h: pointf ep */
   ep: Point;
+  /**
+   * TS-only: the arrow drawn at `sp` (paired with `sflag`). C regenerates it
+   * per bezier at render time (emit.c arrow_gen); the port computes it at clip
+   * time, so it is stored per bezier for splines with several flagged beziers.
+   */
+  sArrowOps?: ArrowDrawOp[];
+  /** TS-only: the arrow drawn at `ep` (paired with `eflag`); see `sArrowOps`. */
+  eArrowOps?: ArrowDrawOp[];
 };
 
 /**

package/src/render/dot.ts

@@ -32,6 +32,7 @@ import { PenType, FillType } from '../gvc/context.js';
 import type { RenderJob } from '../gvc/job.js';
 import { EmitState } from '../gvc/job.js';
 import { renderEdgeLabels } from '../gvc/edge-labels.js';
+import { endArrowOps } from '../common/bezier-arrows.js';
 export * from './dot/xdot-ops.js';
 export * from './dot/attrs.js';
 import {
@@ -226,6 +227,11 @@ export class XdotRenderer extends EdgeDrawBase implements RendererPlugin {
       headArrowColor = c.headColor;
     } else {
       this.emitPlainSpline(e, spl.list, edraw, job);
+      // The plain branch draws an arrow per flagged bezier (emit.c:2669-2675);
+      // the multicolor/tapered branches above draw one per end.
+      for (const ops of endArrowOps(e, 'tail')) this.emitArrows(this.bufs[EmitState.TDraw]!, ops, job, EmitState.TDraw);
+      for (const ops of endArrowOps(e, 'head')) this.emitArrows(this.bufs[EmitState.HDraw]!, ops, job, EmitState.HDraw);
+      return;
     }
     // Arrows: y-up ops already computed for the shared render path. C sets the
     // default line style ("solid") + penwidth before each arrow primitive.

package/src/render/svg-edge-arrows.ts

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// SVG arrowheads for one edge, drawn inside svgEdgePath's per-bezier loop the
+// way emit_edge_graphics calls arrow_gen after each bezier.
+//
+// @see lib/common/emit.c:emit_edge_graphics (2668-2676)
+
+import type { Edge } from '../model/edge.js';
+import type { Bezier } from '../model/geom.js';
+import type { RenderJob } from '../gvc/job.js';
+import { bezierEndOps } from '../common/bezier-arrows.js';
+import { emitArrowOps } from './svg-arrow-ops.js';
+
+/** The edge pen an arrow is drawn with. */
+export interface ArrowPaint { job: RenderJob; penColor: string; opacity: string | null; pw: number }
+
+/** Which ends have drawn their edge-level arrow. */
+export interface ArrowsDone { tailDone: boolean; headDone: boolean }
+
+/**
+ * One end's arrow after bezier `bz`. With several beziers flagged at that end
+ * each draws its own arrow (bezierEndOps); otherwise the edge-level ops are
+ * drawn once, at the first flagged bezier.
+ */
+export function emitBezierEndArrow(
+  e: Edge, bz: Bezier, end: 'head' | 'tail', st: ArrowsDone, p: ArrowPaint,
+): void {
+  const tail = end === 'tail';
+  const flag = tail ? bz.sflag : bz.eflag;
+  const done = tail ? st.tailDone : st.headDone;
+  const edgeOps = tail ? e.info.tailArrowOps : e.info.headArrowOps;
+  const ops = bezierEndOps(e, bz, end)
+    ?? (flag !== 0 && !done && edgeOps?.length ? edgeOps : undefined);
+  if (ops === undefined) return;
+  emitArrowOps(ops, p.penColor, p.job, p.pw, p.opacity);
+  if (tail) st.tailDone = true;
+  else 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.
+ */
+export function emitRemainingArrows(e: Edge, st: ArrowsDone, p: ArrowPaint): void {
+  if (!st.tailDone && e.info.tailArrowOps?.length) {
+    emitArrowOps(e.info.tailArrowOps, p.penColor, p.job, p.pw, p.opacity);
+  }
+  if (!st.headDone && e.info.headArrowOps?.length) {
+    emitArrowOps(e.info.headArrowOps, p.penColor, p.job, p.pw, p.opacity);
+  }
+}

package/src/render/svg-helpers.ts

@@ -66,6 +66,8 @@ 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';
+import { emitBezierEndArrow, emitRemainingArrows } from './svg-edge-arrows.js';
+import type { ArrowPaint } from './svg-edge-arrows.js';
 
 // ---------------------------------------------------------------------------
 // Color helpers
@@ -442,6 +444,11 @@ export function svgEdgePath(e: Edge, job: RenderJob): void {
   if (spl === undefined || spl.size === 0) return;
   const obj = job.obj;
   const stroke = obj !== null ? paintStr(obj, false) : 'black';
+  const paint: ArrowPaint = {
+    job, penColor: stroke,
+    opacity: obj !== null ? colorOpacity(obj.penColor) : null,
+    pw: obj !== null ? obj.penWidth : 1.0,
+  };
   const st = { tailDone: false, headDone: false };
   for (let si = 0; si < spl.size; si++) {
     const bz = spl.list[si] as Bezier | undefined;
@@ -452,51 +459,10 @@ export function svgEdgePath(e: Edge, job: RenderJob): void {
     // 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);
+    emitBezierEndArrow(e, bz, 'tail', st, paint);
+    emitBezierEndArrow(e, bz, 'head', st, paint);
   }
+  emitRemainingArrows(e, st, paint);
 }
 
 /** Emit one bezier as a `<path d="M…C…">`. Extracted from svgEdgePath so the