@knowvah/dot-engine 0.1.0

package/src/common/splines-geom.ts

@@ -0,0 +1,194 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Low-level Bezier geometry helpers ported from lib/common/splines.c
+ * and lib/common/geomprocs.h.
+ *
+ * @see lib/common/splines.c:bezier_clip
+ * @see lib/common/geomprocs.h
+ */
+
+import type { Point, Box } from '../model/geom.js';
+
+// ---------------------------------------------------------------------------
+// Approximate equality
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if distance-squared between p and q is less than tol^2.
+ * @see lib/common/geom.h:APPROXEQPT
+ */
+export function approxEqPt(p: Point, q: Point, tol: number): boolean {
+  const dx = p.x - q.x;
+  const dy = p.y - q.y;
+  return dx * dx + dy * dy < tol * tol;
+}
+
+// ---------------------------------------------------------------------------
+// Bezier evaluation
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluates cubic Bezier sp[] at parameter t.
+ * When left !== null, fills left[0..3] with the left subdivision.
+ * When right !== null, fills right[0..3] with the right subdivision.
+ * Returns the point on the curve.
+ *
+ * @see lib/common/geomprocs.h:Bezier
+ */
+export function evalBezier(
+  sp: Point[],
+  t: number,
+  left: Point[] | null,
+  right: Point[] | null,
+): Point {
+  const ab: Point = { x: sp[0].x + t * (sp[1].x - sp[0].x), y: sp[0].y + t * (sp[1].y - sp[0].y) };
+  const bc: Point = { x: sp[1].x + t * (sp[2].x - sp[1].x), y: sp[1].y + t * (sp[2].y - sp[1].y) };
+  const cd: Point = { x: sp[2].x + t * (sp[3].x - sp[2].x), y: sp[2].y + t * (sp[3].y - sp[2].y) };
+  const abbc: Point = { x: ab.x + t * (bc.x - ab.x), y: ab.y + t * (bc.y - ab.y) };
+  const bccd: Point = { x: bc.x + t * (cd.x - bc.x), y: bc.y + t * (cd.y - bc.y) };
+  const pt: Point = { x: abbc.x + t * (bccd.x - abbc.x), y: abbc.y + t * (bccd.y - abbc.y) };
+  if (left !== null) {
+    left[0] = sp[0]; left[1] = ab; left[2] = abbc; left[3] = pt;
+  }
+  if (right !== null) {
+    right[0] = pt; right[1] = bccd; right[2] = cd; right[3] = sp[3];
+  }
+  return pt;
+}
+
+// ---------------------------------------------------------------------------
+// Bounding box update
+// ---------------------------------------------------------------------------
+
+/** Maximum distance away from the chord, in points. @see lib/common/emit.c:HW */
+const HW = 2.0;
+/** Guard against 0/0 in ptToLine2. @see lib/common/geom.c:SMALL */
+const SMALL = 0.0000000001;
+
+/**
+ * Distance from point p to line a-b, squared.
+ * @see lib/common/geom.c:ptToLine2
+ */
+function ptToLine2(a: Point, b: Point, p: Point): number {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  let a2 = (p.y - a.y) * dx - (p.x - a.x) * dy;
+  a2 *= a2; // square — ensures positive
+  if (a2 < SMALL) return 0; // avoid 0/0 problems
+  return a2 / (dx * dx + dy * dy);
+}
+
+/**
+ * True when the quadrilateral cp is nearly collinear (within HW of the chord),
+ * i.e. the bezier segment is sufficiently refined.
+ * @see lib/common/emit.c:check_control_points
+ */
+function checkControlPoints(cp: Point[]): boolean {
+  const dis1 = ptToLine2(cp[0], cp[3], cp[1]);
+  const dis2 = ptToLine2(cp[0], cp[3], cp[2]);
+  return dis1 < HW * HW && dis2 < HW * HW;
+}
+
+/** True when any control point lies outside bb. */
+function anyOutside(bb: Box, cp: Point[]): boolean {
+  return cp.some(p =>
+    p.x > bb.ur.x || p.x < bb.ll.x || p.y > bb.ur.y || p.y < bb.ll.y);
+}
+
+/** Expand bb by the control points cp. */
+function expandByPoints(bb: Box, cp: Point[]): void {
+  for (const p of cp) {
+    if (p.x > bb.ur.x) bb.ur.x = p.x;
+    else if (p.x < bb.ll.x) bb.ll.x = p.x;
+    if (p.y > bb.ur.y) bb.ur.y = p.y;
+    else if (p.y < bb.ll.y) bb.ll.y = p.y;
+  }
+}
+
+/**
+ * Expands bb to contain the cubic Bezier segment cp by adaptively refining the
+ * segment to its true curve extent (not the control hull).
+ * @see lib/common/emit.c:update_bb_bz
+ */
+export function updateBbBz(bb: Box, cp: Point[]): void {
+  if (!anyOutside(bb, cp)) return;
+  if (checkControlPoints(cp)) {
+    expandByPoints(bb, cp);
+    return;
+  }
+  const left: Point[] = [];
+  const right: Point[] = [];
+  evalBezier(cp, 0.5, left, right);
+  updateBbBz(bb, left);
+  updateBbBz(bb, right);
+}
+
+// ---------------------------------------------------------------------------
+// bezier_clip
+// ---------------------------------------------------------------------------
+
+/**
+ * Context for inside tests — mirrors C inside_t.
+ * @see lib/common/types.h:inside_t
+ */
+export interface InsideContext {
+  /** Node coordinate (ND_coord). */
+  nodeCoord: Point;
+  /** Node right-width (ND_rw) — saved/restored by shape_clip0. */
+  rw: number;
+  /** Optional port box. */
+  bp: Box | null;
+  /** Node being clipped; poly_inside reads its shape info. @see inside_t.s.n */
+  node?: unknown;
+}
+
+/**
+ * Clips Bezier sp[0..3] to a shape boundary using binary search.
+ * `leftInside` specifies that sp[0] is inside (else sp[3] is inside).
+ * Mutates sp in place.
+ *
+ * @see lib/common/splines.c:bezier_clip
+ */
+export function bezierClip(
+  insideCtx: InsideContext,
+  insideFn: (ctx: InsideContext, p: Point) => boolean,
+  sp: Point[],
+  leftInside: boolean,
+): void {
+  // left/right subdivision results
+  const seg: Point[] = [
+    { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 },
+  ];
+  const best: Point[] = [
+    { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 }, { x: 0, y: 0 },
+  ];
+  const left = leftInside ? null : seg;
+  const right = leftInside ? seg : null;
+  let pt: Point = leftInside ? { x: sp[0].x, y: sp[0].y } : { x: sp[3].x, y: sp[3].y };
+  let low = 0.0;
+  let high = 1.0;
+  let found = false;
+  do {
+    const opt = pt;
+    const t = (high + low) / 2.0;
+    pt = evalBezier(sp, t, left, right);
+    if (insideFn(insideCtx, pt)) {
+      if (leftInside) { low = t; } else { high = t; }
+      for (let i = 0; i < 4; i++) best[i] = { x: seg[i].x, y: seg[i].y };
+      found = true;
+    } else {
+      if (leftInside) { high = t; } else { low = t; }
+    }
+    // Convergence: mirror C's loop continuation `while (ABS(dx) > .5 ||
+    // ABS(dy) > .5)` EXACTLY — break when neither exceeds 0.5. Written as the
+    // negation of C's `>` test (not `<=`) so it is NaN-equivalent to C: for a
+    // NaN delta both `>` and `<=` are false, so `!(NaN > .5 || NaN > .5)` is
+    // true (stop, as C does), whereas `NaN <= .5 && NaN <= .5` is false (spin
+    // forever). NaN control points occur when a layout blows up (e.g. sfdp
+    // under a large repulsiveforce), and C terminates on them.
+    if (!(Math.abs(opt.x - pt.x) > 0.5 || Math.abs(opt.y - pt.y) > 0.5)) break;
+  } while (true); // eslint-disable-line no-constant-condition
+  const src = found ? best : seg;
+  for (let i = 0; i < 4; i++) sp[i] = src[i];
+}

package/src/common/splines-path-begin.ts

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * beginpath — sets up routing boxes at the tail (start) node.
+ * Ported from lib/common/splines.c:beginpath.
+ *
+ * @see lib/common/splines.c:beginpath
+ */
+
+import type { Box } from '../model/geom.js';
+import type { Path, PathendT, ShapeDesc } from './types.js';
+import type { Edge } from '../model/edge.js';
+import type { Node } from '../model/node.js';
+import { TOP, BOTTOM, LEFT, RIGHT, FUDGE, REGULAREDGE, FLATEDGE } from './splines-constants.js';
+import {
+  resolvePort, clearClipForOrig, applyDefaultBoxes,
+  invokePboxfn, setStartTheta,
+} from './splines-path-shared.js';
+
+/** Bundled beginpath context to stay within MAX_PARAMS=5. */
+interface BeginCtx {
+  P: Path;
+  e: Edge;
+  n: Node;
+  endp: PathendT;
+  ranksep: number;
+}
+
+// ---------------------------------------------------------------------------
+// REGULAREDGE side helpers
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/splines.c:beginpath TOP branch */
+class BeginRegSide {
+  static topLeft(ctx: BeginCtx): void {
+    const { P, n, endp, ranksep } = ctx;
+    const b = endp.nb;
+    endp.boxes[0] = {
+      ll: { x: b.ll.x - 1, y: P.start.p.y },
+      ur: { x: b.ur.x, y: n.info.coord.y + n.info.ht / 2 + ranksep / 2 },
+    };
+    endp.boxes[1] = {
+      ll: { x: b.ll.x - 1, y: n.info.coord.y - n.info.ht / 2 },
+      ur: { x: n.info.coord.x - n.info.lw - (FUDGE - 2), y: P.start.p.y },
+    };
+  }
+
+  static topRight(ctx: BeginCtx): void {
+    const { P, n, endp, ranksep } = ctx;
+    const b = endp.nb;
+    endp.boxes[0] = {
+      ll: { x: b.ll.x, y: P.start.p.y },
+      ur: { x: b.ur.x + 1, y: n.info.coord.y + n.info.ht / 2 + ranksep / 2 },
+    };
+    endp.boxes[1] = {
+      ll: { x: n.info.coord.x + n.info.rw + (FUDGE - 2), y: n.info.coord.y - n.info.ht / 2 },
+      ur: { x: b.ur.x + 1, y: P.start.p.y },
+    };
+  }
+
+  static top(ctx: BeginCtx): void {
+    const { P, n, e, endp } = ctx;
+    if (P.start.p.x < n.info.coord.x) BeginRegSide.topLeft(ctx);
+    else BeginRegSide.topRight(ctx);
+    endp.sidemask = TOP;
+    endp.boxn = 2;
+    P.start.p.y += 1;
+    clearClipForOrig(e, n, true);
+  }
+
+  static bottom(ctx: BeginCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: endp.nb.ll,
+      ur: { x: endp.nb.ur.x, y: Math.max(endp.nb.ur.y, P.start.p.y) },
+    };
+    endp.sidemask = BOTTOM;
+    endp.boxn = 1;
+    P.start.p.y -= 1;
+    clearClipForOrig(e, n, true);
+  }
+
+  static left(ctx: BeginCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: { x: endp.nb.ll.x, y: n.info.coord.y - n.info.ht / 2 },
+      ur: { x: P.start.p.x, y: P.start.p.y },
+    };
+    endp.sidemask = LEFT;
+    endp.boxn = 1;
+    P.start.p.x -= 1;
+    clearClipForOrig(e, n, true);
+  }
+
+  static right(ctx: BeginCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: { x: P.start.p.x, y: n.info.coord.y - n.info.ht / 2 },
+      ur: { x: endp.nb.ur.x, y: P.start.p.y },
+    };
+    endp.sidemask = RIGHT;
+    endp.boxn = 1;
+    P.start.p.x += 1;
+    clearClipForOrig(e, n, true);
+  }
+
+  static dispatch(ctx: BeginCtx, side: number): void {
+    if (side & TOP) BeginRegSide.top(ctx);
+    else if (side & BOTTOM) BeginRegSide.bottom(ctx);
+    else if (side & LEFT) BeginRegSide.left(ctx);
+    else BeginRegSide.right(ctx);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// FLATEDGE side helpers
+// ---------------------------------------------------------------------------
+
+class BeginFlatSide {
+  static bottom(ctx: BeginCtx, b: Box): void {
+    const { P, n, endp, ranksep } = ctx;
+    if (endp.sidemask === TOP) {
+      endp.boxes[0] = {
+        ll: { x: P.start.p.x, y: n.info.coord.y - n.info.ht / 2 - ranksep / 2 },
+        ur: { x: b.ur.x + 1, y: n.info.coord.y - n.info.ht / 2 },
+      };
+      endp.boxes[1] = {
+        ll: { x: n.info.coord.x + n.info.rw + (FUDGE - 2), y: n.info.coord.y - n.info.ht / 2 },
+        ur: { x: b.ur.x + 1, y: n.info.coord.y + n.info.ht / 2 },
+      };
+      endp.boxn = 2;
+    } else {
+      endp.boxes[0] = {
+        ll: b.ll,
+        ur: { x: b.ur.x, y: Math.max(b.ur.y, P.start.p.y) },
+      };
+      endp.boxn = 1;
+    }
+    P.start.p.y -= 1;
+  }
+
+  static left(ctx: BeginCtx, b: Box): void {
+    const { P, n, endp } = ctx;
+    const top = endp.sidemask === TOP;
+    endp.boxes[0] = {
+      ll: { x: b.ll.x, y: top ? P.start.p.y - 1 : n.info.coord.y - n.info.ht / 2 },
+      ur: { x: P.start.p.x + 1, y: top ? n.info.coord.y + n.info.ht / 2 : P.start.p.y + 1 },
+    };
+    endp.boxn = 1;
+    P.start.p.x -= 1;
+  }
+
+  static right(ctx: BeginCtx, b: Box): void {
+    const { P, n, endp } = ctx;
+    const top = endp.sidemask === TOP;
+    endp.boxes[0] = {
+      ll: { x: P.start.p.x, y: top ? P.start.p.y : n.info.coord.y - n.info.ht / 2 },
+      ur: { x: b.ur.x, y: top ? n.info.coord.y + n.info.ht / 2 : P.start.p.y + 1 },
+    };
+    endp.boxn = 1;
+    P.start.p.x += 1;
+  }
+
+  static dispatch(ctx: BeginCtx, side: number): void {
+    const { P, n, e, endp } = ctx;
+    const b = endp.nb;
+    if (side & TOP) {
+      endp.boxes[0] = {
+        ll: { x: b.ll.x, y: Math.min(b.ll.y, P.start.p.y) },
+        ur: b.ur,
+      };
+      endp.boxn = 1;
+      P.start.p.y += 1;
+    } else if (side & BOTTOM) {
+      BeginFlatSide.bottom(ctx, b);
+    } else if (side & LEFT) {
+      BeginFlatSide.left(ctx, b);
+    } else {
+      BeginFlatSide.right(ctx, b);
+    }
+    clearClipForOrig(e, n, true);
+    endp.sidemask = side;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Default path
+// ---------------------------------------------------------------------------
+
+function beginDefaultPath(ctx: BeginCtx, et: number): void {
+  const { P, e, n, endp } = ctx;
+  const side = et === REGULAREDGE ? BOTTOM : endp.sidemask;
+  // C beginpath sources pboxfn from ND_shape(n)->fns->pboxfn (splines.c:389).
+  const fns = (n.info.shape as ShapeDesc | undefined)?.fns ?? null;
+  const mask = invokePboxfn(fns, n, e.info.tail_port, side, endp);
+  if (mask) { endp.sidemask = mask; return; }
+  endp.boxes[0] = endp.nb;
+  endp.boxn = 1;
+  applyDefaultBoxes(P, et, endp);
+}
+
+// ---------------------------------------------------------------------------
+// beginPath (public)
+// ---------------------------------------------------------------------------
+
+/** Arguments for beginPath; bundles params to stay within MAX_PARAMS=5. */
+export interface BeginPathArgs {
+  P: Path;
+  e: Edge;
+  et: number;
+  endp: PathendT;
+  merge: boolean;
+  ranksep: number;
+}
+
+/**
+ * Sets up path boxes near the tail node.
+ * @see lib/common/splines.c:beginpath
+ */
+export function beginPath(args: BeginPathArgs): void {
+  const { P, e, et, endp, merge, ranksep } = args;
+  const n = e.tail;
+  if (e.info.tail_port.dyna) {
+    e.info.tail_port = resolvePort(n, e.head, e.info.tail_port);
+  }
+  P.start.p = {
+    x: n.info.coord.x + e.info.tail_port.p.x,
+    y: n.info.coord.y + e.info.tail_port.p.y,
+  };
+  setStartTheta(P, e, merge);
+  P.nbox = 0;
+  P.data = e;
+  endp.np = { x: P.start.p.x, y: P.start.p.y };
+  const ctx: BeginCtx = { P, e, n, endp, ranksep };
+  const side = e.info.tail_port.side;
+  if (et === REGULAREDGE && n.info.node_type === 0 && side) {
+    BeginRegSide.dispatch(ctx, side); return;
+  }
+  if (et === FLATEDGE && side) {
+    BeginFlatSide.dispatch(ctx, side); return;
+  }
+  beginDefaultPath(ctx, et);
+}

package/src/common/splines-path-end.ts

@@ -0,0 +1,231 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * endpath — sets up routing boxes at the head (end) node.
+ * Ported from lib/common/splines.c:endpath.
+ *
+ * @see lib/common/splines.c:endpath
+ */
+
+import type { Box } from '../model/geom.js';
+import type { Path, PathendT, ShapeDesc } from './types.js';
+import type { Edge } from '../model/edge.js';
+import type { Node } from '../model/node.js';
+import { TOP, BOTTOM, LEFT, FUDGE, REGULAREDGE, FLATEDGE } from './splines-constants.js';
+import {
+  resolvePort, clearClipForOrig, applyEndDefaultBoxes,
+  invokePboxfn, setEndTheta,
+} from './splines-path-shared.js';
+
+/** Arguments for endPath; bundles params to stay within MAX_PARAMS=5. */
+export interface EndPathArgs {
+  P: Path;
+  e: Edge;
+  et: number;
+  endp: PathendT;
+  merge: boolean;
+  ranksep: number;
+}
+
+/** Bundled endpath context to stay within MAX_PARAMS=5. */
+interface EndCtx {
+  P: Path;
+  e: Edge;
+  n: Node;
+  endp: PathendT;
+  ranksep: number;
+}
+
+// ---------------------------------------------------------------------------
+// REGULAREDGE side helpers
+// ---------------------------------------------------------------------------
+
+class EndRegSide {
+  static bottom(ctx: EndCtx): void {
+    const { P, n, e, endp, ranksep } = ctx;
+    const b = endp.nb;
+    if (P.end.p.x < n.info.coord.x) {
+      endp.boxes[0] = {
+        ll: { x: b.ll.x - 1, y: n.info.coord.y - n.info.ht / 2 - ranksep / 2 },
+        ur: { x: b.ur.x, y: P.end.p.y },
+      };
+      endp.boxes[1] = {
+        ll: { x: b.ll.x - 1, y: P.end.p.y },
+        ur: { x: n.info.coord.x - n.info.lw - (FUDGE - 2), y: n.info.coord.y + n.info.ht / 2 },
+      };
+    } else {
+      endp.boxes[0] = {
+        ll: { x: b.ll.x, y: n.info.coord.y - n.info.ht / 2 - ranksep / 2 },
+        ur: { x: b.ur.x + 1, y: P.end.p.y },
+      };
+      endp.boxes[1] = {
+        ll: { x: n.info.coord.x + n.info.rw + (FUDGE - 2), y: P.end.p.y },
+        ur: { x: b.ur.x + 1, y: n.info.coord.y + n.info.ht / 2 },
+      };
+    }
+    endp.boxn = 2;
+    P.end.p.y -= 1;
+    clearClipForOrig(e, n, false);
+  }
+
+  static top(ctx: EndCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: { x: endp.nb.ll.x, y: Math.min(endp.nb.ll.y, P.end.p.y) },
+      ur: endp.nb.ur,
+    };
+    endp.sidemask = TOP;
+    endp.boxn = 1;
+    P.end.p.y += 1;
+    clearClipForOrig(e, n, false);
+  }
+
+  static left(ctx: EndCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: { x: endp.nb.ll.x, y: P.end.p.y },
+      ur: { x: P.end.p.x, y: n.info.coord.y + n.info.ht / 2 },
+    };
+    endp.boxn = 1;
+    P.end.p.x -= 1;
+    clearClipForOrig(e, n, false);
+  }
+
+  static right(ctx: EndCtx): void {
+    const { P, n, e, endp } = ctx;
+    endp.boxes[0] = {
+      ll: { x: P.end.p.x, y: P.end.p.y },
+      ur: { x: endp.nb.ur.x, y: n.info.coord.y + n.info.ht / 2 },
+    };
+    endp.boxn = 1;
+    P.end.p.x += 1;
+    clearClipForOrig(e, n, false);
+  }
+
+  static dispatch(ctx: EndCtx, side: number): void {
+    const { endp } = ctx;
+    if (side & TOP) EndRegSide.top(ctx);
+    else if (side & BOTTOM) EndRegSide.bottom(ctx);
+    else if (side & LEFT) EndRegSide.left(ctx);
+    else EndRegSide.right(ctx);
+    endp.sidemask = side;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// FLATEDGE side helpers
+// ---------------------------------------------------------------------------
+
+class EndFlatSide {
+  static bottom(ctx: EndCtx, b: Box): void {
+    const { P, n, endp, ranksep } = ctx;
+    if (endp.sidemask === TOP) {
+      endp.boxes[0] = {
+        ll: { x: b.ll.x - 1, y: n.info.coord.y - n.info.ht / 2 - ranksep / 2 },
+        ur: { x: P.end.p.x, y: n.info.coord.y - n.info.ht / 2 },
+      };
+      endp.boxes[1] = {
+        ll: { x: b.ll.x - 1, y: n.info.coord.y - n.info.ht / 2 },
+        ur: { x: n.info.coord.x - n.info.lw - 2, y: n.info.coord.y + n.info.ht / 2 },
+      };
+      endp.boxn = 2;
+    } else {
+      endp.boxes[0] = {
+        ll: b.ll,
+        ur: { x: b.ur.x, y: Math.max(b.ur.y, P.start.p.y) },
+      };
+      endp.boxn = 1;
+    }
+    P.end.p.y -= 1;
+  }
+
+  static left(ctx: EndCtx, b: Box): void {
+    const { P, n, endp } = ctx;
+    const top = endp.sidemask === TOP;
+    endp.boxes[0] = {
+      ll: { x: b.ll.x, y: top ? P.end.p.y - 1 : n.info.coord.y - n.info.ht / 2 },
+      ur: { x: P.end.p.x + 1, y: top ? n.info.coord.y + n.info.ht / 2 : P.end.p.y + 1 },
+    };
+    endp.boxn = 1;
+    P.end.p.x -= 1;
+  }
+
+  static right(ctx: EndCtx, b: Box): void {
+    const { P, n, endp } = ctx;
+    const top = endp.sidemask === TOP;
+    endp.boxes[0] = {
+      ll: { x: P.end.p.x - 1, y: top ? P.end.p.y - 1 : n.info.coord.y - n.info.ht / 2 },
+      ur: { x: b.ur.x, y: top ? n.info.coord.y + n.info.ht / 2 : P.end.p.y },
+    };
+    endp.boxn = 1;
+    P.end.p.x += 1;
+  }
+
+  static dispatch(ctx: EndCtx, side: number): void {
+    const { P, n, e, endp } = ctx;
+    const b = endp.nb;
+    if (side & TOP) {
+      endp.boxes[0] = {
+        ll: { x: b.ll.x, y: Math.min(b.ll.y, P.end.p.y) },
+        ur: b.ur,
+      };
+      endp.boxn = 1;
+      P.end.p.y += 1;
+    } else if (side & BOTTOM) {
+      EndFlatSide.bottom(ctx, b);
+    } else if (side & LEFT) {
+      EndFlatSide.left(ctx, b);
+    } else {
+      EndFlatSide.right(ctx, b);
+    }
+    clearClipForOrig(e, n, false);
+    endp.sidemask = side;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Default path
+// ---------------------------------------------------------------------------
+
+function endDefaultPath(ctx: EndCtx, et: number): void {
+  const { P, e, n, endp } = ctx;
+  const side = et === REGULAREDGE ? TOP : endp.sidemask;
+  // C endpath sources pboxfn from ND_shape(n)->fns->pboxfn (splines.c:586).
+  const fns = (n.info.shape as ShapeDesc | undefined)?.fns ?? null;
+  const mask = invokePboxfn(fns, n, e.info.head_port, side, endp);
+  if (mask) { endp.sidemask = mask; return; }
+  endp.boxes[0] = endp.nb;
+  endp.boxn = 1;
+  applyEndDefaultBoxes(P, et, endp);
+}
+
+// ---------------------------------------------------------------------------
+// endPath (public)
+// ---------------------------------------------------------------------------
+
+/**
+ * Sets up path boxes near the head node.
+ * @see lib/common/splines.c:endpath
+ */
+export function endPath(args: EndPathArgs): void {
+  const { P, e, et, endp, merge, ranksep } = args;
+  const n = e.head;
+  if (e.info.head_port.dyna) {
+    e.info.head_port = resolvePort(n, e.tail, e.info.head_port);
+  }
+  P.end.p = {
+    x: n.info.coord.x + e.info.head_port.p.x,
+    y: n.info.coord.y + e.info.head_port.p.y,
+  };
+  setEndTheta(P, e, merge);
+  endp.np = { x: P.end.p.x, y: P.end.p.y };
+  const ctx: EndCtx = { P, e, n, endp, ranksep };
+  const side = e.info.head_port.side;
+  if (et === REGULAREDGE && n.info.node_type === 0 && side) {
+    EndRegSide.dispatch(ctx, side); return;
+  }
+  if (et === FLATEDGE && side) {
+    EndFlatSide.dispatch(ctx, side); return;
+  }
+  endDefaultPath(ctx, et);
+}