@knowvah/dot-engine 0.1.0

package/dist/layout/dot/edge-route-boxes.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Box assembly helpers for edge spline routing.
+ *
+ * Constructs the path boxes (tail, rank, head) that define the corridor
+ * through which a spline is routed.
+ *
+ * @see lib/common/splines.c:beginpath
+ * @see lib/common/splines.c:endpath
+ * @see lib/dotgen/dotsplines.c:rank_box
+ * @see lib/dotgen/dotsplines.c:maximal_bbox
+ */
+import type { Box } from '../../model/geom.js';
+import type { NodeBox } from './edge-route-geom.js';
+/**
+ * Assemble the tail-side box (beginpath, REGULAREDGE, no port).
+ *
+ * C sets boxes[0].UR.y = start.p.y. In TS SVG coords C's UR.y maps to
+ * our ll.y. The tail box spans ll.y=startPy (center) to ur.y (bottom).
+ *
+ * @see lib/common/splines.c:beginpath
+ */
+/**
+ * Tail box: nb with ur.y overridden to startPy (= beginpath UR.y = center.y).
+ * C: endp->boxes[0] = nb; endp->boxes[0].UR.y = P->start.p.y
+ * @see lib/common/splines.c:beginpath REGULAREDGE case
+ */
+export declare function makeTailBox(nb: Box, startPy: number): Box;
+/**
+ * Assemble the head-side box (endpath, REGULAREDGE, no port).
+ *
+ * C sets boxes[0].LL.y = end.p.y. In TS SVG coords C's LL.y maps to
+ * our ur.y. The head box spans ll.y (top) to ur.y=endPy (center).
+ *
+ * @see lib/common/splines.c:endpath
+ */
+/**
+ * Head box: nb with ll.y overridden to endPy (= endpath LL.y = center.y).
+ * C: endp->boxes[0] = nb; endp->boxes[0].LL.y = P->end.p.y
+ * @see lib/common/splines.c:endpath REGULAREDGE case
+ */
+export declare function makeHeadBox(nb: Box, endPy: number): Box;
+/** Parameters for makeRankBox — avoids a 6-parameter signature. */
+export interface RankBoxParams {
+    llx: number;
+    urx: number;
+    tailCy: number;
+    tailHt1: number;
+    headCy: number;
+    headHt2: number;
+}
+/**
+ * Inter-rank space box between two adjacent ranks.
+ *
+ * In TS SVG coords: ll.y = tailCy+tailHt1 (bottom of tail node),
+ * ur.y = headCy-headHt2 (top of head node).
+ *
+ * @see lib/dotgen/dotsplines.c:rank_box
+ */
+/**
+ * Inter-rank space box: from head node top (ll.y) to tail node bottom (ur.y).
+ * C: ll.y = headCy + headHt2  (= B.top = 90+18=108)
+ *    ur.y = tailCy - tailHt1  (= A.bottom = 162-18=144)
+ * @see lib/dotgen/dotsplines.c:rank_box
+ */
+export declare function makeRankBox(p: RankBoxParams): Box;
+/**
+ * Node bounding box for maximal_bbox (simple node, no neighbors).
+ *
+ * ll = { x: cx-lw-FUDGE, y: cy-ht1 }  (top-left in SVG)
+ * ur = { x: cx+rw+FUDGE, y: cy+ht2 }  (bottom-right in SVG)
+ *
+ * @see lib/dotgen/dotsplines.c:maximal_bbox
+ */
+export declare function makeMaximalBbox(box: NodeBox, ht1: number, ht2: number): Box;
+//# sourceMappingURL=edge-route-boxes.d.ts.map

package/dist/layout/dot/edge-route-boxes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-boxes.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-boxes.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAKpD;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,GAAG,GAAG,CAEzD;AAED;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAEvD;AAED,mEAAmE;AACnE,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,aAAa,GAAG,GAAG,CAKjD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,GAAG,CAK3E"}

package/dist/layout/dot/edge-route-chain.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Multi-rank edge routing via virtual-node chains.
+ *
+ * Both back-edges (tail.rank > head.rank) and forward edges spanning
+ * more than one rank (head.rank > tail.rank + 1) are routed by
+ * walking the virtual-node chain that class2/makeChain created and
+ * building a corridor-box path through every intermediate rank.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (hackflag path)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Edge as GraphEdge } from '../../model/edge.js';
+import type { Point } from '../../model/geom.js';
+import type { NodeBox } from './edge-route-geom.js';
+/**
+ * Route a forward edge spanning ≥2 ranks via its virtual-node chain through the
+ * faithful pipeline (REGULAREDGE side boxes steer the port, routeSplines over
+ * the chain; adjustregularpath inter-rank widening finally fires). Returns
+ * control points in graphviz-internal y-up, or null when the edge is not a
+ * multi-rank chain.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (hackflag forward path)
+ */
+export declare function routeMultiRankEdgeFaithful(g: Graph, e: GraphEdge): Point[] | null;
+/**
+ * Route ONE collected entry's merge-bounded run — C's model where every
+ * fast-graph entry of a concentrate-merged chain (lead-in from the real node,
+ * trunk continuation out of a merge node, or a secondary's branch) is its own
+ * cnt=1 group (the group loop's MAINGRAPH break) and make_regular_edge walks
+ * from the entry to the first NORMAL or splineMerge node; clip_and_install
+ * then APPENDS the clipped bezier on the entry's original edge. The entry's
+ * own ports drive begin/endpath (the last segment carries the run's head
+ * port), and the install passes the ENTRY (its to_orig chain resolves the
+ * orig) with the walk's final head node, exactly as C.
+ *
+ * Returns the resolved original edge when the entry was a partial run
+ * (consumed — even if routing declined, so the caller never re-routes the
+ * whole chain), or null when the entry is a plain full chain.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (group loop), make_regular_edge
+ */
+export declare function routeEntryRun(g: Graph, entry: GraphEdge): GraphEdge | null;
+/**
+ * Forward view of any edge (C `makefwdedge`): tail/head swapped when the edge
+ * runs high→low rank (a back edge), fresh portless ends. `beginPath`/`endPath`
+ * read `e.tail`/`e.head`, so the chain must be driven by an edge that runs
+ * low→high rank. Sets `to_orig`/`edge_type=VIRTUAL` so `clipAndInstall`→
+ * `newSpline` installs the spline on the ORIGINAL edge (its `to_orig` loop) and
+ * the post-routing `swapSpline` pass reverses it back to tail→head. Shares
+ * `attrs`/`root`/`to_virt` with `e`. Consumed by T3 for parallel back-members.
+ * @see lib/dotgen/dotsplines.c:makefwdedge
+ * @see lib/common/splines.c:clip_and_install (to_orig install loop)
+ */
+export declare function makeFwdEdge(e: GraphEdge): GraphEdge;
+/**
+ * Route a multi-rank back-edge via its virtual node chain, mirroring C exactly:
+ * make_regular_edge routes the makefwdedge (forward) view, clip_and_install
+ * clips THAT forward spline, and the spline is reversed afterward (swapSpline).
+ *
+ * Clipping the forward (un-reversed) spline is load-bearing: bezier_clip bisects
+ * each node end from the same direction C does. The previous reverse-then-clip
+ * path clipped the head node as a tail (bisecting the degenerate spline from the
+ * opposite parameter end), landing the 0.5-tolerance crossing ~0.26-0.33 off
+ * (1644, dfa family). clipAndInstall resolves the spline onto `e` via the
+ * fwdEdge's to_orig and gates arrows by ED_dir, so this also drops the bespoke
+ * reverse/arrow code. @see lib/dotgen/dotsplines.c:make_regular_edge (hackflag)
+ */
+export declare function routeBackEdge(e: GraphEdge, _tailBox: NodeBox, _headBox: NodeBox, g: Graph): void;
+//# sourceMappingURL=edge-route-chain.d.ts.map

package/dist/layout/dot/edge-route-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-chain.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-chain.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAO,MAAM,qBAAqB,CAAC;AAGtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAqNpD;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,SAAS,GAAG,KAAK,EAAE,GAAG,IAAI,CAwBjF;AAuBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAO1E;AA8CD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAoBnD;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CAiBhG"}

package/dist/layout/dot/edge-route-clip.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Bezier subdivision and node-boundary clipping for edge spline routing.
+ *
+ * @see lib/common/utils.c:Bezier
+ * @see lib/common/splines.c:bezier_clip
+ * @see lib/common/splines.c:shape_clip0
+ */
+import type { Point } from '../../model/geom.js';
+/**
+ * De Casteljau subdivision of a cubic Bezier at parameter t.
+ * Returns [left4, right4, midpoint].
+ * @see lib/common/utils.c:Bezier
+ */
+export declare function bezierSubdivide(sp: Point[], t: number): [Point[], Point[], Point];
+/**
+ * Clip Bezier to node boundary using binary search.
+ *
+ * sp is in global coords. insideFn receives node-local coords (center
+ * subtracted). leftInside=true: sp[0] is inside node (tail clip).
+ * leftInside=false: sp[3] is inside node (head clip).
+ *
+ * @see lib/common/splines.c:bezier_clip
+ * @see lib/common/splines.c:shape_clip0
+ */
+export declare function bezierClipNode(sp: Point[], cx: number, cy: number, insideFn: (lx: number, ly: number) => boolean, leftInside: boolean): Point[];
+/**
+ * Clip the path endpoint to the arrowhead BASE (not node boundary).
+ *
+ * Ports lib/common/arrows.c:arrowEndClip.
+ * The path ends at arrowhead-BASE (arrowTip + elen toward tail), not at the
+ * node boundary. The arrowTip (spl.ep) is the node-boundary clip result.
+ *
+ * Steps (matching C arrowEndClip):
+ * 1. Reverse the last Bezier segment: sp[0]=arrowTip, sp[1..3]=reversed path
+ * 2. inside = DIST(p, arrowTip) <= elen (arrowhead sphere)
+ * 3. bezierClip with left_inside=true (sp[0]=arrowTip is "inside" the sphere)
+ * 4. Un-reverse the clipped right subdivision → path ends at arrowhead BASE
+ *
+ * @see lib/common/arrows.c:arrowEndClip
+ */
+export declare function arrowEndClip(path4: Point[], arrowTip: Point, elen: number): Point[];
+/**
+ * Per-type spline clip length for an arrow string: the sum of the parsed
+ * compound arrow's component lengths (`arrow_length`). Replaces the normal-only
+ * `normalArrowLen` so non-normal arrows clip by their true length (ADR-4); the
+ * caller still gates on the edge flag (no clip when the end has no arrow).
+ * @see lib/common/arrows.c:arrow_length (:253)
+ */
+export declare function arrowClipLength(arrowName: string, arrowsize: number, penwidth: number): number;
+/**
+ * Default node pen width. @see lib/common/const.h:DEFAULT_NODEPENWIDTH
+ */
+export declare const DEFAULT_NODEPENWIDTH = 1;
+/**
+ * Returns a box-shape inside function for use with bezierClipNode.
+ *
+ * Matches C's poly_inside bounding-box test which uses the OUTLINE boundary
+ * (node + penwidth/2) rather than the geometric boundary:
+ *   box_URx = (lw + rw + penwidth) / 2
+ *   box_URy = (ht + penwidth) / 2
+ *
+ * @see lib/common/shapes.c:poly_inside (box_URx/box_URy computation)
+ */
+export declare function makeBoxInsideFn(halfW: number, halfH: number, penwidth?: number): (lx: number, ly: number) => boolean;
+/**
+ * Returns an ellipse-shape inside function for use with bezierClipNode.
+ *
+ * Matches C's poly_inside ellipse branch (sides <= 2):
+ *   hypot(P.x/box_URx, P.y/box_URy) < 1  (strict less-than, matching C)
+ * where box_URx = lw + penwidth/2 and box_URy = ht/2 + penwidth/2.
+ *
+ * C uses strict < 1 (not <=) — the one-bit difference matters during
+ * binary search: a point exactly on the boundary is classified as outside
+ * in C, which determines when the search terminates.
+ *
+ * @see lib/common/shapes.c:poly_inside (sides <= 2 branch)
+ */
+export declare function makeEllipseInsideFn(rx: number, ry: number, penwidth?: number): (lx: number, ly: number) => boolean;
+/**
+ * Clip path START to the tail arrowhead base (symmetric to arrowEndClip).
+ *
+ * path4[0] = tail node boundary (inside arrowhead sphere); after clip,
+ * path4[0] = arrowhead base (elen from tailTip).
+ *
+ * @see lib/common/arrows.c:arrowEndClip
+ */
+export declare function tailArrowEndClip(path4: Point[], tailTip: Point, elen: number): Point[];
+//# sourceMappingURL=edge-route-clip.d.ts.map

package/dist/layout/dot/edge-route-clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-clip.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-clip.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAiCjD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,KAAK,EAAE,EACX,CAAC,EAAE,MAAM,GACR,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,CAK3B;AA2DD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,EAC7C,UAAU,EAAE,OAAO,GAClB,KAAK,EAAE,CAMT;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,KAAK,EAAE,EACd,QAAQ,EAAE,KAAK,EACf,IAAI,EAAE,MAAM,GACX,KAAK,EAAE,CAcT;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG9F;AAED;;GAEG;AACH,eAAO,MAAM,oBAAoB,IAAM,CAAC;AAExC;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,QAAQ,SAAuB,GAC9B,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAKrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,SAAuB,GAC9B,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAKrC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,KAAK,EAAE,EACd,OAAO,EAAE,KAAK,EACd,IAAI,EAAE,MAAM,GACX,KAAK,EAAE,CAIT"}

package/dist/layout/dot/edge-route-faithful.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Faithful adjacent-rank regular-edge routing for dot.
+ *
+ * Assembles the `beginPath → completeRegularPath → routeSplines` box-channel
+ * pipeline that C's `make_regular_edge` uses. This is the sequence the
+ * simplified active fitter (`buildRankCorridor`/`computeSpline`) bypasses;
+ * the simplified fitter truncates the non-monotonic loop corridor a steering
+ * port needs (tail exits the TOP face while the head is below). routeSplines
+ * routes that corridor completely.
+ *
+ * SR2 scope: regular **adjacent-rank** edges only. Returns the spline control
+ * points in graphviz-internal y-up coordinates (the frame dot's router runs
+ * in; SVG y-negation is a later render pass). `clipAndInstall` + arrows +
+ * `routeOneEdge` wiring is SR3 — this module does not install anything.
+ *
+ * Deviations from C, journaled in decision-journal.md (SR2):
+ * - Cluster bounds (`cl_bound`) in maximal_bbox are not ported; no batch-2/3
+ *   test graph has clusters. The neighbor branch uses node extents only.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ * @see lib/dotgen/dotsplines.c:completeregularpath
+ * @see lib/dotgen/dotsplines.c:adjustregularpath
+ * @see lib/dotgen/dotsplines.c:makeregularend
+ * @see lib/dotgen/dotsplines.c:maximal_bbox
+ * @see lib/dotgen/dotsplines.c:rank_box
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { Box, Point } from '../../model/geom.js';
+import type { Path, PathendT } from '../../common/types.js';
+/**
+ * Per-call routing bounds, mirroring the fields of spline_info_t that
+ * maximal_bbox / rank_box read.
+ * @see lib/dotgen/dotsplines.c:spline_info_t
+ */
+export interface SplineBounds {
+    leftBound: number;
+    rightBound: number;
+    splinesep: number;
+}
+/** Bundled context for the maximal_bbox helpers (keeps params <= 5). */
+export interface BboxCtx {
+    g: Graph;
+    sp: SplineBounds;
+}
+/** Bundled arguments for completeRegularPath (keeps params <= 5). */
+export interface RegularPathParts {
+    P: Path;
+    first: Edge;
+    last: Edge;
+    tend: PathendT;
+    hend: PathendT;
+    boxes: Box[];
+}
+/**
+ * Build the initial bounding box for begin/endpath at node vn.
+ * @see lib/dotgen/dotsplines.c:maximal_bbox
+ */
+export declare function maximalBbox(ctx: BboxCtx, vn: Node, ie: Edge | undefined, oe: Edge | undefined): Box;
+/**
+ * Override the endpoint box's y-extent from the last begin/endpath box, then
+ * append a makeregularend box if it is non-degenerate.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (b.UR.y/LL.y + makeregularend)
+ */
+export declare function appendRegularEnd(nb: Box, endp: PathendT, side: number, y: number): void;
+/**
+ * Inter-rank space box spanning the full routing width between rank r (tail)
+ * and rank r+1 (head).
+ * @see lib/dotgen/dotsplines.c:rank_box
+ */
+export declare function rankBox(ctx: BboxCtx, r: number): Box;
+/**
+ * Concatenate tail boxes, inter-rank boxes (forward), and head boxes
+ * (reversed) into P, then widen. Returns false if a bounding edge is unrouted.
+ * @see lib/dotgen/dotsplines.c:completeregularpath
+ */
+export declare function completeRegularPath(parts: RegularPathParts): boolean;
+/** A fresh path endpoint seeded with its node bounding box. */
+export declare function freshEndp(nb: Box): PathendT;
+/**
+ * Route a regular adjacent-rank edge through the faithful box-channel
+ * pipeline. Returns spline control points in graphviz-internal (y-up)
+ * coordinates; null when the edge is not an adjacent-rank regular edge or
+ * the path cannot be assembled (decline — the caller may fall back); or
+ * 'lost' when the full corridor was attempted and routesplines itself
+ * failed — C installs no spline and the edge is LOST (map_edge warns, emit
+ * skips), never straight-line synthesized. Does NOT clip or install.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (adjacent-rank, no virtual chain)
+ * @see lib/common/routespl.c:routesplines (failure -> NULL, edge lost)
+ */
+export declare function routeRegularEdgeFaithful(g: Graph, e: Edge): Point[] | null | 'lost';
+//# sourceMappingURL=edge-route-faithful.d.ts.map

package/dist/layout/dot/edge-route-faithful.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-faithful.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-faithful.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAuB5D;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,wEAAwE;AACxE,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,KAAK,CAAC;IACT,EAAE,EAAE,YAAY,CAAC;CAClB;AAED,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAC/B,CAAC,EAAE,IAAI,CAAC;IACR,KAAK,EAAE,IAAI,CAAC;IACZ,IAAI,EAAE,IAAI,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,GAAG,EAAE,CAAC;CACd;AAsGD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,SAAS,GAAG,GAAG,CAanG;AAgBD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAKvF;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAQpD;AAyFD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAUpE;AAMD,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,EAAE,EAAE,GAAG,GAAG,QAAQ,CAE3C;AAOD;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,KAAK,EAAE,GAAG,IAAI,GAAG,MAAM,CA8BnF"}

package/dist/layout/dot/edge-route-geom.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Geometric helpers for edge spline routing: vector math and node-box
+ * ray clipping.
+ *
+ * @see lib/common/splines.c:clip_and_install (box-clipping logic)
+ */
+import type { Point } from '../../model/geom.js';
+/** Normalize a 2-D vector; returns {0,0} if near-zero length. */
+export declare function normalizeVec(v: Point): Point;
+/** Reverse a vector. */
+export declare function negateVec(v: Point): Point;
+/** Offset a point by dir * scale. */
+export declare function offsetPoint(p: Point, dir: Point, scale: number): Point;
+/** Min positive t along x-axis for the given boundary half-width. */
+export declare function xClipT(dirX: number, halfW: number): number;
+/** Min positive t along y-axis for the given boundary half-height. */
+export declare function yClipT(dirY: number, halfH: number): number;
+/**
+ * Node box dimensions bundled for clipping.
+ * @see lib/common/types.h:Agnodeinfo_t (ND_lw, ND_rw, ND_ht)
+ */
+export interface NodeBox {
+    center: Point;
+    lw: number;
+    rw: number;
+    ht: number;
+    /** True when the node shape is elliptical (sides === 1 in C poly_inside). */
+    isEllipse?: boolean;
+    /**
+     * Node pen width. C's poly_inside clips to the outline periphery (the
+     * boundary grown by penwidth/2), so a thick-bordered node clips the edge
+     * spline / arrow slightly further out. Defaults to DEFAULT_NODEPENWIDTH.
+     * @see lib/common/shapes.c:poly_inside (outline / penwidth)
+     */
+    penwidth?: number;
+}
+/**
+ * Clip a ray from box.center in direction `dir` to the node boundary.
+ * For ellipse nodes uses the ellipse formula; for box nodes uses the box formula.
+ * @see lib/common/shapes.c:poly_inside
+ */
+export declare function clipToNodeBox(box: NodeBox, dir: Point): Point;
+//# sourceMappingURL=edge-route-geom.d.ts.map

package/dist/layout/dot/edge-route-geom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-geom.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-geom.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAMjD,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAI5C;AAED,wBAAwB;AACxB,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAAiC;AAE3E,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAEtE;AAMD,qEAAqE;AACrE,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAI1D;AAED;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,KAAK,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,GAAG,KAAK,CAgB7D"}

package/dist/layout/dot/edge-route-helpers.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared helpers for edge spline routing: node-box construction,
+ * penwidth reading, spline record installation, and straight-edge routing.
+ *
+ * Extracted to allow edge-route-chain.ts to import these without
+ * creating a circular dependency through the top-level edge-route.ts.
+ *
+ * @see lib/dotgen/dotsplines.c
+ * @see lib/common/splines.c:clip_and_install
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge as GraphEdge } from '../../model/edge.js';
+import type { Point, Bezier, Spline } from '../../model/geom.js';
+import type { NodeBox } from './edge-route-geom.js';
+import type { RankEdgeInfo, EdgeSplineResult, PortRoute } from './edge-route-routing.js';
+/**
+ * Default `dir` for an edge given the graph's directedness. C uses
+ * `agisdirected(g) ? "forward" : "none"` — an undirected graph draws no
+ * arrowheads. Without this, undirected edges wrongly get a head arrow and an
+ * arrow-clipped (short) spline.
+ *
+ * @see lib/common/arrows.c:arrow_flags (late_string E_dir default)
+ */
+export declare function defaultEdgeDir(g: Graph): string;
+/** Returns a NodeBox with defaulted lw/rw/ht for a node. */
+export declare function nodeBoxOf(n: Node, g: Graph): NodeBox;
+/**
+ * Effective pen width for arrowhead geometry. Must mirror the stroke resolver
+ * so the arrow's penwidth-dependent miter (delta_tip/delta_base in
+ * arrow_type_normal0) matches the drawn line width: penwidth attr →
+ * setlinewidth(N) style → bold(2.0) → 1.0. The prior version only recognised
+ * `style === "bold"`, so `style="setlinewidth(3)"` fell through to 1.0 and the
+ * arrow was drawn ~penwidth off along the edge (graphs-style a->e).
+ * @see resolvePenWidth (style-resolve.ts) / lib/common/arrows.c:257
+ */
+export declare function edgeRenderPenwidth(e: GraphEdge): number;
+/** Penwidth for arrow-length (elen) computation (attribute only). */
+export declare function edgePenwidthAttr(e: GraphEdge): number;
+/** Build a Bezier record for a single cubic segment. */
+export declare function makeBezierRecord(bezierPts: Point[], arrowTip: Point): Bezier;
+/** Build a zero-bb Spline wrapping a single Bezier record. */
+export declare function makeSplineRecord(bz: Bezier): Spline;
+/** Create and install a Spline on the edge. @see lib/common/splines.c:clip_and_install */
+export declare function installEdgeSpline(e: GraphEdge, bezierPts: Point[], arrowTip: Point): void;
+/** Route via pathplan, falling back to linear if the result is degenerate. */
+export declare function routeBezier(from: Point, to: Point): Point[];
+/** Compute Bezier for a straight edge, with optional rank-corridor geometry. */
+export declare function straightEdgeSplineWithRank(tailBox: NodeBox, headBox: NodeBox, rankInfo: RankEdgeInfo | undefined, penwidth?: number, port?: PortRoute): EdgeSplineResult;
+//# sourceMappingURL=edge-route-helpers.d.ts.map

package/dist/layout/dot/edge-route-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-helpers.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-helpers.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAOjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAE/C;AAyBD,4DAA4D;AAC5D,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAepD;AAMD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAEvD;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAGrD;AAOD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,GAAG,MAAM,CAM5E;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,0FAA0F;AAC1F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,GAAG,IAAI,CAYzF;AAaD,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,KAAK,EAAE,CAM3D;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,YAAY,GAAG,SAAS,EAClC,QAAQ,SAAM,EACd,IAAI,CAAC,EAAE,SAAS,GACf,gBAAgB,CAIlB"}

package/dist/layout/dot/edge-route-poly.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Polygon construction and spline routing from path boxes.
+ *
+ * Ports the box-to-polygon conversion and spline fitting sections of
+ * routesplines_ in the C source.
+ *
+ * @see lib/common/routespl.c:routesplines_
+ */
+import type { Point, Box } from '../../model/geom.js';
+import type { Edge as BarrierEdge } from '../../pathplan/types.js';
+/**
+ * Forward pass: right-side polygon vertices from box[0] to box[N-1].
+ * @see lib/common/routespl.c:routesplines_ (forward loop)
+ */
+export declare function addForwardPolyPts(boxes: Box[], pts: Point[]): void;
+/**
+ * Reverse pass: left-side polygon vertices from box[N-1] to box[0].
+ * @see lib/common/routespl.c:routesplines_ (reverse loop)
+ */
+export declare function addReversePolyPts(boxes: Box[], pts: Point[]): void;
+/**
+ * Convert path boxes to polygon vertices.
+ *
+ * Boxes are in tail→head path order. In TS SVG coords (y-down), ll.y
+ * increases from tail to head — this is the C post-flip state, so the
+ * forward+reverse pass logic ports directly.
+ *
+ * @see lib/common/routespl.c:routesplines_
+ */
+export declare function boxesToPolygon(boxes: Box[]): Point[];
+/** Build polygon barrier edges (consecutive pairs, closed). */
+export declare function polyEdgesFromPts(polygon: Point[]): BarrierEdge[];
+/** Straight-line cubic Bezier with control points at 1/3 and 2/3. */
+export declare function linearBezier(p0: Point, p3: Point): Point[];
+/**
+ * Fit spline via routeSpline.
+ * Degenerate Beziers (P0=P1) are valid — C's Proutespline produces them
+ * for straight paths with zero endpoint slopes, and bezier_clip still
+ * gives correct clipping behavior.
+ * @see lib/pathplan/route.c:reallyroutespline (splinefits section)
+ */
+export declare function tryRouteSpline(barriers: BarrierEdge[], wpts: Point[]): Point[] | null;
+/**
+ * Build polygon from boxes, find shortest path, fit Bezier with barriers.
+ * @see lib/common/routespl.c:routesplines_
+ */
+export declare function computeSpline(boxes: Box[], startPt: Point, endPt: Point): Point[];
+//# sourceMappingURL=edge-route-poly.d.ts.map

package/dist/layout/dot/edge-route-poly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-poly.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-poly.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,KAAK,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAoCnE;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,CAKlE;AAuCD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,IAAI,CAKlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,KAAK,EAAE,CAMpD;AAOD,+DAA+D;AAC/D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,GAAG,WAAW,EAAE,CAGhE;AAED,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,KAAK,EAAE,CAO1D;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,KAAK,EAAE,GAAG,IAAI,CAKrF;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,KAAK,EAAE,CAOjF"}

package/dist/layout/dot/edge-route-rank.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Rank geometry extraction for edge routing.
+ *
+ * Computes the RankEdgeInfo needed by routeWithRank by reading the
+ * graph's rank table and deriving left/right bounds from node extents.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (rank geometry access)
+ * @see lib/dotgen/dotsplines.c:sd.LeftBound / sd.RightBound
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { RankEdgeInfo } from './edge-route-routing.js';
+/** Minimum x extent across all nodes minus MINW. @see lib/dotgen/dotsplines.c:sd.LeftBound */
+export declare function computeLeftBound(g: Graph): number;
+/** Maximum x extent across all nodes plus MINW. @see lib/dotgen/dotsplines.c:sd.RightBound */
+export declare function computeRightBound(g: Graph): number;
+/** Default a rank half-height to node half-height when the rank value is unset. */
+export declare function rankHt(rankVal: number, nodeHt: number): number;
+/** The two fields of spline_info_t that this port derives from live rank/node
+ *  state. @see lib/dotgen/dotsplines.c:spline_info_t (LeftBound/RightBound) */
+export interface SplineBoundsSnapshot {
+    leftBound: number;
+    rightBound: number;
+}
+/**
+ * Return this pass's frozen {leftBound, rightBound}, computing it on first
+ * access after a `resetSplineBounds` (or the very first access ever, for a
+ * graph never routed before). C's `dot_splines_` computes `spline_info_t sd`
+ * ONCE per call and threads it by pointer/value through every routing
+ * helper for that pass; the port previously called computeLeftBound/
+ * computeRightBound fresh on every routed edge, so edges routed later in the
+ * same pass saw a corridor narrowed by recoverSlack/resizeVn mutations to
+ * vnode coord.x/lw/rw from EARLIER edges in the pass (measured on 2646:
+ * 6002 of the pass's bound reads drifted 26pt narrower per side; the very
+ * first, pre-mutation computeLeftBound call is byte-identical to C's
+ * one-time value, so the formula is faithful and only the call timing
+ * drifted). NOTE: 2646's residual 3-edge divergence (Δ42.09 worst) proved
+ * to be a separate mechanism — those edges route before/independent of the
+ * drift — but the frozen snapshot is the faithful C semantics regardless.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (sd computed once, threaded through)
+ */
+export declare function getSplineBounds(g: Graph): SplineBoundsSnapshot;
+/**
+ * Force the next `getSplineBounds(g)` call to recompute a fresh snapshot.
+ * Called once at the top of each `dotSplines_` pass (main graph or aux
+ * graph), exactly where C zero-initializes then computes `spline_info_t sd`
+ * fresh for that call. @see lib/dotgen/dotsplines.c:dot_splines_ (`spline_info_t
+ * sd = {0};` followed by the one-time LeftBound/RightBound loop)
+ */
+export declare function resetSplineBounds(g: Graph): void;
+/**
+ * Extract RankEdgeInfo from the graph's rank table for an edge.
+ * Returns undefined if rank geometry is not available.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (rank geometry access)
+ */
+export declare function rankEdgeInfoOf(g: Graph, tailNode: Node, headNode: Node): RankEdgeInfo | undefined;
+//# sourceMappingURL=edge-route-rank.d.ts.map

package/dist/layout/dot/edge-route-rank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-rank.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-rank.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAK5D,8FAA8F;AAC9F,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAYjD;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAalD;AAED,mFAAmF;AACnF,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9D;AAQD;+EAC+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,oBAAoB,CAO9D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,KAAK,EACR,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,IAAI,GACb,YAAY,GAAG,SAAS,CAgB1B"}