@knowvah/dot-engine 0.1.0

package/dist/layout/dot/splines-clone.d.ts

@@ -0,0 +1,33 @@
+/**
+ * cloneNode / cloneEdge for the flat-adj recursive pipeline.
+ *
+ * @see lib/dotgen/dotsplines.c:cloneNode, cloneEdge, cleanupCloneGraph
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { Point } from '../../model/geom.js';
+/**
+ * Map a point from the flat-adj auxiliary frame back to the original frame:
+ * un-rotate when the original graph is flipped, then translate by del.
+ * @see lib/dotgen/dotsplines.c:transformf
+ */
+export declare function transformf(p: Point, del: Point, flip: boolean): Point;
+/**
+ * Create a copy of orign in graph g, carrying geometry from NodeInfo.
+ * @see lib/dotgen/dotsplines.c:cloneNode
+ */
+export declare function cloneNode(g: Graph, orign: Node): Node;
+/**
+ * Create a copy of orig between tn→hn in graph g.
+ * @see lib/dotgen/dotsplines.c:cloneEdge
+ */
+export declare function cloneEdge(g: Graph, tn: Node, hn: Node, orig: Edge): Edge;
+/**
+ * Release all resources held by the auxiliary clone graph.
+ * In the C implementation this restores global Agsyms and calls dot_cleanup.
+ * In TypeScript, clearing node and edge collections is sufficient.
+ * @see lib/dotgen/dotsplines.c:cleanupCloneGraph
+ */
+export declare function cleanupCloneGraph(auxg: Graph): void;
+//# sourceMappingURL=splines-clone.d.ts.map

package/dist/layout/dot/splines-clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-clone.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-clone.ts"],"names":[],"mappings":"AAEA;;;;GAIG;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,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAKjD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,GAAG,KAAK,CAGrE;AAOD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,GAAG,IAAI,CA0CrD;AAOD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,CAexE;AAOD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,CAInD"}

package/dist/layout/dot/splines-flat-labeled.d.ts

@@ -0,0 +1,101 @@
+/**
+ * make_flat_labeled_edge — route a non-adjacent same-rank (flat) edge that
+ * carries a center label, around the label virtual node created by flat_node
+ * (flat.ts:flatNode, T1). Sets the label position and installs the spline.
+ *
+ * Split out of splines-flat.ts (which is at the file-size cap) and reuses its
+ * makeFlatEndBox / flatBboxCtx / freshFlatPath helpers. Dispatched from the
+ * live router (edge-route.ts:routeForwardEdge) — see decisions.md#ad-3.
+ *
+ * @see lib/dotgen/dotsplines.c:make_flat_labeled_edge
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+import type { Node } from '../../model/node.js';
+import type { Box, Point } from '../../model/geom.js';
+/**
+ * Walk `ED_to_virt(e)` to the end of the chain; the tail of the last edge is the
+ * label virtual node `ln`. @see lib/dotgen/dotsplines.c:make_flat_labeled_edge 1328-1330
+ */
+export declare function findLabelNode(e: Edge): Node | null;
+/**
+ * The label box `lb` straddling the label node, with the C `ydelta`/6 clamp.
+ * @see lib/dotgen/dotsplines.c:make_flat_labeled_edge 1349-1355
+ */
+export declare function flatLabelBox(g: Graph, ln: Node, tn: Node): Box;
+/**
+ * The three connector boxes between the tail end, label box, and head end.
+ * @see lib/dotgen/dotsplines.c:make_flat_labeled_edge 1360-1393
+ */
+export declare function flatLabeledBoxes(tlast: Box, hlast: Box, lb: Box): Box[];
+/**
+ * EDGETYPE_LINE 7-point polyline: start, label (lowered by half label height),
+ * end. @see lib/dotgen/dotsplines.c:make_flat_labeled_edge 1335-1347
+ */
+export declare function flatLabeledLinePoints(tn: Node, hn: Node, e: Edge): Point[];
+/**
+ * Build the tail/label/head box channel and route a spline (or polyline)
+ * through it. @see lib/dotgen/dotsplines.c:make_flat_labeled_edge 1349-1411
+ */
+export declare function routeFlatLabeledChannel(g: Graph, e: Edge, ln: Node, et: number): Point[] | null;
+/**
+ * Decline unless `e` is a non-adjacent, same-rank, labeled flat edge with a
+ * label vnode reachable via its to_virt chain; otherwise return that vnode.
+ */
+export declare function flatLabelTarget(e: Edge): Node | null;
+/**
+ * Route a non-adjacent labeled flat edge around its label vnode and install the
+ * spline. Sets `ED_label(e).pos` / `.set` so the label `<text>` is emitted.
+ * Returns false (declining) when `e` is not such an edge so the caller falls
+ * back to its normal routing. @see lib/dotgen/dotsplines.c:make_flat_labeled_edge
+ */
+export declare function makeFlatLabeledEdge(g: Graph, e: Edge): boolean;
+/**
+ * True when `e` is an adjacent, same-rank flat edge with no declared ports —
+ * C's make_flat_adj_edges no-port dispatch (makeSimpleFlat / makeSimpleFlatLabels).
+ * Port-bearing adjacent flats route via the rotated aux graph instead.
+ *
+ * `adjacent` is read from the flat representative — the end of the `to_virt`
+ * chain — not from `e` directly. C's `dot_splines_` routes the `flat_out`/`other`
+ * edge that `checkFlatAdjacent` marked; the port instead routes the cgraph
+ * out-edge, which for a nonconstraint cross-cluster flat (e.g. 258 `B->D`) is a
+ * *different* object linked to the marked representative through `to_virt`
+ * (R -> v -> M, with `adjacent` set on M). Following the chain reunites the
+ * routed edge with its flag. For an ordinary adjacent flat the chain is empty,
+ * so the rep is `e` itself. @see lib/dotgen/dotsplines.c:dot_splines_ (flat gather)
+ */
+export declare function isAdjFlatCandidate(e: Edge): boolean;
+/**
+ * Group: every no-port adjacent flat edge between e's two endpoints, in BOTH
+ * directions (the UNORDERED {tail,head} set). C's make_flat_adj_edges groups by
+ * the unordered pair — opposing legs (a->b and b->a) and parallel siblings route
+ * as one call (dotsplines.c:1122; the dispatch loop's "all flat adjacent edges
+ * at once" at dotsplines.c:357). Keying on the ordered (tail,head) split the
+ * opposing leg into its own cnt=1 group, drawn straight instead of as the
+ * earray[1] arc. @see lib/dotgen/flat.c:flat_edges (ND_other)
+ */
+export declare function collectAdjFlatGroup(g: Graph, e: Edge): Edge[];
+/** edgelblcmpfn: labeled first; among labeled, larger dimen (x then y) first. */
+export declare function edgeLblCmp(a: Edge, b: Edge): number;
+/**
+ * Route a parallel group of adjacent (no-port) flat edges: the first goes
+ * straight with its label above; the rest stack up/down around the rank, each
+ * routed via simpleSplineRoute. @see lib/dotgen/dotsplines.c:makeSimpleFlatLabels
+ */
+export declare function makeSimpleFlatLabels(group: Edge[], et: number): void;
+/**
+ * Spindle of splines for a no-port, no-label adjacent flat group: fan the cnt
+ * edges vertically across the tail node's height (stepy = ht/(cnt-1), centred
+ * on tp.y). cnt == 1 yields a single straight line.
+ * @see lib/dotgen/dotsplines.c:makeSimpleFlat (1075)
+ */
+export declare function makeSimpleFlat(group: Edge[], et: number): void;
+/**
+ * Dispatch an adjacent no-port flat edge group (C's `make_flat_adj_edges`
+ * no-port branch): a group with any label routes via makeSimpleFlatLabels, a
+ * group with none via makeSimpleFlat. Both route the whole parallel group at
+ * once. Declines only when `e` is not a no-port adjacent flat.
+ * @see lib/dotgen/dotsplines.c:make_flat_adj_edges 1156-1166
+ */
+export declare function makeAdjFlatNoPortEdge(g: Graph, e: Edge): boolean;
+//# sourceMappingURL=splines-flat-labeled.d.ts.map

package/dist/layout/dot/splines-flat-labeled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-flat-labeled.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-flat-labeled.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;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;AAetD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAKlD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,GAAG,CAQ9D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,GAAG,EAAE,CAMvE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,KAAK,EAAE,CAa1E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,IAAI,CAa/F;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAIpD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAgC9D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAgBnD;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,CAS7D;AAcD,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAOnD;AA4FD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAyBpE;AAiBD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAa9D;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAWhE"}

package/dist/layout/dot/splines-flat-multi.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Faithful cnt>=2 non-adjacent flat multi-edge routing.
+ *
+ * C make_flat_edge (top branch, dotsplines.c:1502) and make_flat_bottom_edges
+ * (bottom branch, 1418) group every non-labeled, identical-port, non-adjacent
+ * flat edge between a same-rank node pair into ONE call and NEST their splines:
+ * `stepx = Multisep/(cnt+1)`, `stepy = vspace/(cnt+1)`; ONE shared makeFlatEnd
+ * tail+head; then edge `i` is offset by `(i+1)*step` on the two END boxes while
+ * the MIDDLE box keeps plain `stepy`. cnt=1 reduces to routeFlatEdgeFaithful
+ * (`Multisep/2 = nodesep/2`, `(0+1)*step = step`) — identical (AD-1).
+ *
+ * The port routes each non-adjacent flat independently at `nodesep/2`, so cnt>=2
+ * edges come out identical/overlapping; this module restores the nesting.
+ *
+ * @see lib/dotgen/dotsplines.c:make_flat_edge, make_flat_bottom_edges, dot_splines_
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+/**
+ * Collect all unrouted non-adjacent same-rank side-port flat edges between e's
+ * endpoints that share e's tail/head ports (C portcmp), ordered so group[0].tail
+ * is the lower-order (left) node, ties by seq (AD-3). Mirrors edge-route.ts:
+ * collectAdjacentFlatGroup with the non-adjacent + identical-port group key.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (portcmp 370-373), make_flat_edge
+ */
+export declare function collectNonAdjacentFlatGroup(e: Edge, g: Graph): Edge[];
+/**
+ * Faithful make_flat_edge / make_flat_bottom_edges cnt-loop: ONE shared
+ * makeFlatEnd tail+head; for i in 0..cnt-1 route edge i nested by (i+1)*step.
+ * Installs spl on every edges[i]; returns true iff all installed. cnt=1 reduces
+ * to routeFlatEdgeFaithful (AD-1). `edges` must be group-ordered (collect...).
+ * @see lib/dotgen/dotsplines.c:make_flat_edge, make_flat_bottom_edges
+ */
+export declare function routeFlatEdgeGroupFaithful(g: Graph, edges: Edge[], cnt: number): boolean;
+//# sourceMappingURL=splines-flat-multi.d.ts.map

package/dist/layout/dot/splines-flat-multi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-flat-multi.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-flat-multi.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAgEhD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,CAcrE;AAyCD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAkCxF"}

package/dist/layout/dot/splines-flat.d.ts

@@ -0,0 +1,116 @@
+/**
+ * make_flat_edge, make_flat_adj_edges and helpers — flat edge spline routing.
+ *
+ * Flat edges connect nodes on the same rank. The adjacent-node case
+ * (make_flat_adj_edges) recursively invokes the full dot pipeline on a
+ * cloned subgraph. Full pathplan routing is deferred until pathplan.ts
+ * is ported.
+ *
+ * @see lib/dotgen/dotsplines.c:make_flat_edge, make_flat_adj_edges
+ */
+import { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+import type { Node } from '../../model/node.js';
+import type { Box, Point } from '../../model/geom.js';
+import type { Path, PathendT } from '../../common/types.js';
+import type { SplineInfo } from './splines-route.js';
+import { type BboxCtx } from './edge-route-faithful.js';
+/** Bundled args for makeFlatEndBox (keeps params <= 5). Declared here (not
+ * between functions) so lizard's TS parser doesn't fold it into a neighbor. */
+export interface FlatEndParts {
+    ctx: BboxCtx;
+    P: Path;
+    e: Edge;
+    n: Node;
+    side: number;
+    ranksep: number;
+    isBegin: boolean;
+}
+/**
+ * Create a minimal clone of g for flat-adj routing.
+ * @see lib/dotgen/dotsplines.c:cloneGraph
+ */
+export declare function cloneGraph(g: Graph): Graph;
+/** Run rank, mincross, position on auxg; return non-zero on failure. */
+export declare function runAuxPipeline(auxg: Graph): number;
+/** Run sameports + splines (no normalize) on auxg; return non-zero on failure. */
+export declare function runAuxSplines(auxg: Graph): number;
+/**
+ * Route adjacent flat edges (with ports) via a rotated auxiliary layout, then
+ * transform the resulting splines back onto the original edges. Installs splines
+ * directly on the originals (returns 0 on success). Records and the no-port
+ * makeSimpleFlat branch are out of scope (callers gate on a side port).
+ * @see lib/dotgen/dotsplines.c:make_flat_adj_edges
+ */
+export declare function makeFlatAdjEdges(g: Graph, edges: Edge[], cnt: number, _et: number): number;
+/**
+ * True when a same-rank edge's endpoints are adjacent in rank order (no NORMAL
+ * or labeled-virtual node between them) — the make_flat_adj_edges case.
+ * @see lib/dotgen/flat.c:checkFlatAdjacent
+ */
+export declare function isFlatAdjacent(g: Graph, e: Edge): boolean;
+/**
+ * Route a group of flat (same-rank) edges.
+ * @see lib/dotgen/dotsplines.c:make_flat_edge
+ */
+export declare function makeFlatEdge(g: Graph, _sp: SplineInfo, edges: Edge[], cnt: number, et: number): number;
+/**
+ * makeFlatEnd (side=TOP) / makeBottomFlatEnd (side=BOTTOM): seed the endpoint
+ * box from maximal_bbox, set the side mask, run begin/endpath (FLATEDGE feeds
+ * BeginFlatSide/EndFlatSide), then append the makeregularend box up to (TOP) or
+ * down from (BOTTOM) the node's rank extent.
+ * @see lib/dotgen/dotsplines.c:makeFlatEnd, makeBottomFlatEnd
+ */
+export declare function makeFlatEndBox(parts: FlatEndParts): PathendT;
+/**
+ * The three connecting boxes for the top-routing branch (loop over the top).
+ * END boxes offset by `endStepX`/`endStepY` (C `(i+1)·step`); MIDDLE box keeps
+ * height `midStepY` (C plain `stepy`). cnt=1 ⇒ all three = step (original).
+ * @see lib/dotgen/dotsplines.c:make_flat_edge (boxes[], loop body)
+ */
+export declare function topBoxes(tlast: Box, hlast: Box, endStepX: number, endStepY: number, midStepY: number): Box[];
+/**
+ * The three connecting boxes for the bottom-routing branch (loop under).
+ * END/MIDDLE step semantics mirror `topBoxes`; cnt=1 ⇒ all = step (original).
+ * @see lib/dotgen/dotsplines.c:make_flat_bottom_edges (boxes[], loop body)
+ */
+export declare function bottomBoxes(tlast: Box, hlast: Box, endStepX: number, endStepY: number, midStepY: number): Box[];
+/**
+ * Vertical space available for the loop. Top routing reads the rank above;
+ * bottom routing reads the rank below; either way a node at the graph
+ * boundary falls back to ranksep.
+ * @see lib/dotgen/dotsplines.c:make_flat_edge / make_flat_bottom_edges (vspace)
+ */
+export declare function flatVspace(g: Graph, tn: Node, top: boolean): number;
+/** A fresh empty path for begin/route/end assembly. */
+export declare function freshFlatPath(): Path;
+/** Per-caller spline_info bounds (C builds its own `sd` per orchestrator).
+ *  Splinesep = GD_nodesep(g) / 4 with INTEGER division (C's GD_nodesep is an
+ *  `int`, types.h:334; dotsplines.c:267 builds one sd shared by regular + flat
+ *  routing). A float divide here (nodesep/2 = 9) over-widens the VIRTUAL-
+ *  neighbor gap in maximal_bbox; truncate to nodesep/4 to mirror C. */
+export declare function flatBboxCtx(g: Graph): BboxCtx;
+/**
+ * Routing-side decision: bottom routing fires when a BOTTOM port faces away
+ * from a non-TOP opposite end, exactly as C's
+ * `(tside==BOTTOM && hside!=TOP) || (hside==BOTTOM && tside!=TOP)`.
+ * @see lib/dotgen/dotsplines.c:make_flat_edge (tside/hside test)
+ */
+export declare function flatSide(e: Edge): {
+    bottom: boolean;
+    side: number;
+};
+/** Concatenate tail boxes (fwd), the 3 connecting boxes, head boxes (rev). */
+export declare function assembleFlatPath(P: Path, tend: PathendT, hend: PathendT, mid: Box[]): void;
+/**
+ * Route a single same-rank (flat) edge carrying a side-mask port through the
+ * faithful `beginPath → routeSplines → endPath → clipAndInstall` pipeline.
+ * Returns spline control points in graphviz-internal (y-up) coordinates, or
+ * null when the edge is not a same-rank edge. Does NOT clip or install — the
+ * caller (routeOneEdge) does that via clipAndInstall, mirroring how SR3 wires
+ * the regular faithful path.
+ *
+ * @see lib/dotgen/dotsplines.c:make_flat_edge (cnt=1, non-adjacent spline)
+ */
+export declare function routeFlatEdgeFaithful(g: Graph, e: Edge): Point[] | null;
+//# sourceMappingURL=splines-flat.d.ts.map

package/dist/layout/dot/splines-flat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-flat.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-flat.ts"],"names":[],"mappings":"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"}

package/dist/layout/dot/splines-groups.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Edge-group formation and dispatch for the dot_splines_ routing loop —
+ * C's inner group loop (groupSize) and the per-group router selection.
+ *
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (343-419)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Edge } from '../../model/edge.js';
+/** Per-loop routing context: separations, edge type, per-run orig record. */
+export interface GroupRouteCtx {
+    multisep: number;
+    et: number;
+    /** Originals that received per-run bezier appends (normalized post-loop). */
+    runOrigs: Set<Edge>;
+}
+/**
+ * Collapse a main-edge group to one representative per distinct original edge.
+ * The opposing `a->b`/`b->a` case collects three entries but two distinct
+ * originals; dedup by `resolveOrigEdge` yields one per original (parallels
+ * untouched). Pushes the RESOLVED original `o`, not the raw group member `e`:
+ * a raw member can be a swapped internal proxy (e.g. a same-rank flat edge
+ * whose canonical orientation is tail/head-swapped) whose endpoints don't
+ * match the edge actually rendered — routing against the proxy leaves the
+ * real edge's geometry unset. C's `edges` list carries no such proxy object
+ * (its group members are already the real/virtual edges), so this recovers
+ * C's outcome for the TS-specific proxy representation. Distinct originals
+ * (genuine parallels, or a multi-rank edge's own per-hop virtual segments)
+ * each resolve to their OWN root, so this dedup never merges or renames them.
+ * @see dotsplines.c:make_regular_edge (one clip_and_install per orig)
+ */
+export declare function dedupByOrig(group: Edge[]): Edge[];
+/**
+ * Run the whole group-routing loop over the sorted edge list; returns the set
+ * of originals that received per-run bezier appends, for the caller's
+ * post-loop normalize pass. @see lib/dotgen/dotsplines.c:dot_splines_ (343-419)
+ */
+export declare function routeEdgeGroups(g: Graph, edges: Edge[], multisep: number, et: number): Set<Edge>;
+//# sourceMappingURL=splines-groups.d.ts.map

package/dist/layout/dot/splines-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-groups.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-groups.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAahD,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;CACrB;AAqCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAUjD;AAyFD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAIhG"}

package/dist/layout/dot/splines-label.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Label placement for edge virtual nodes and port labels.
+ *
+ * @see lib/dotgen/dotsplines.c:place_vnlabel, setEdgeLabelPos
+ * @see lib/common/splines.c:place_portlabel (lines 1316-1360)
+ * @see lib/dotgen/dotsplines.c:440-458 (port-label placement loop)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { TextlabelT } from '../../common/types.js';
+/** Minimal label shape sufficient for placement. */
+export interface TextLabel {
+    pos: {
+        x: number;
+        y: number;
+    };
+    dimen: {
+        x: number;
+        y: number;
+    };
+    set: boolean;
+}
+/** Cast an unknown label to TextLabel if it has the required shape. */
+export declare function asTextLabel(label: unknown): TextLabel | undefined;
+/** Walk to_orig until edge_type is NORMAL (0). */
+export declare function findNormalOutEdge(first: Edge): Edge | undefined;
+/** Compute label x-position from node coord, dimen, and flip flag. */
+export declare function labelXPos(n: Node, l: TextLabel): number;
+/**
+ * Assign position of an edge label from its virtual node.
+ * @see lib/dotgen/dotsplines.c:place_vnlabel
+ */
+export declare function placeVnlabel(n: Node): void;
+/** Set label pos from posAlg edge for virtual label nodes. */
+export declare function setAlgLabelPos(n: Node): void;
+/**
+ * Set edge label position information for regular and non-adjacent flat edges.
+ * @see lib/dotgen/dotsplines.c:setEdgeLabelPos
+ */
+export declare function setEdgeLabelPos(g: Graph): void;
+/** Default port-label distance in points. @see lib/common/const.h:PORT_LABEL_DISTANCE */
+export declare const PORT_LABEL_DISTANCE = 10;
+/** Default port-label angle in degrees (CW negative). @see lib/common/const.h:PORT_LABEL_ANGLE */
+export declare const PORT_LABEL_ANGLE = -25;
+/**
+ * Place the head or tail port label for edge e.
+ *
+ * Returns true on success, false when:
+ *   - edge_type is IGNORED, or
+ *   - neither labelangle nor labeldistance attrs are set (labels are then
+ *     treated as external xlabel-style labels, not placed here), or
+ *   - the spline is not yet computed.
+ *
+ * NOTE: The C code only places port labels when at least one of
+ * E_labelangle / E_labeldistance has a non-empty value. When both are
+ * absent (the common case), it returns 0 and the labels remain unpositioned.
+ * In the C pipeline the renderer then falls back to xlabel-style placement.
+ * For the quarantine reference, the labels *are* placed — meaning one of
+ * the two attrs has an implicit value in the C attr-symbol table.  We
+ * replicate the C condition faithfully: check whether the edge's own
+ * attrs contain a non-empty value for either key.
+ *
+ * @see lib/common/splines.c:place_portlabel
+ */
+export declare function placePortlabel(e: Edge, headP: boolean): boolean;
+/** Expand g.info.bb to include the label's bounding box. */
+export declare function updateBB(g: Graph, l: TextlabelT): void;
+/**
+ * After edge routing completes, place regular edge labels from virtual nodes
+ * and expand the graph bounding box to include each label.
+ *
+ * Called once per graph after the parallel-edge routing loop and before
+ * edge_normalize.  Mirrors the C post-routing place_vnlabel + updateBB loop
+ * at dotsplines.c:422-430.  Flat-edge virtual nodes (in.size == 0) are
+ * skipped inside placeVnlabel as in C.
+ *
+ * @see lib/dotgen/dotsplines.c:422-430
+ */
+export declare function placeRegularEdgeLabels(g: Graph): void;
+/**
+ * Walk all nodes and edges; call placePortlabel for head/tail labels.
+ *
+ * C's gates are on the attribute DECLARATIONS, not on `GD_has_labels`:
+ *
+ *   if ((E_headlabel || E_taillabel) && (E_labelangle || E_labeldistance)) {
+ *       for (n = agfstnode(g); ...) {
+ *           if (E_headlabel) { ...place_portlabel(e, true)... }
+ *           if (E_taillabel) { ...place_portlabel(e, false)... }
+ *       }
+ *   }
+ *
+ * The port previously gated the two inner branches on
+ * `GD_has_labels & HEAD_LABEL/TAIL_LABEL`. That is NOT C, and it broke under
+ * `pack`: `has_labels` is OR'd onto the true cgraph root (`common_init_edge`,
+ * utils.c:521), so a projected component's own flag is 0 and BOTH branches were
+ * skipped — the head/tail labels kept their unplaced default position instead
+ * of being offset by labelangle/labeldistance. The per-edge
+ * `ED_head_label == NULL` checks inside the loops already do the real filtering,
+ * exactly as in C.
+ *
+ * @see lib/dotgen/dotsplines.c:440-458
+ */
+export declare function placePortLabels(g: Graph): void;
+//# sourceMappingURL=splines-label.d.ts.map

package/dist/layout/dot/splines-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-label.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-label.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;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,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAUxD,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9B,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,GAAG,EAAE,OAAO,CAAC;CACd;AAMD,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAMjE;AAED,kDAAkD;AAClD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAI/D;AAED,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,GAAG,MAAM,CAIvD;AAOD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAW1C;AAOD,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAO5C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAe9C;AAOD,yFAAyF;AACzF,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC,kGAAkG;AAClG,eAAO,MAAM,gBAAgB,MAAM,CAAC;AA8EpC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAM/D;AAyED,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,GAAG,IAAI,CActD;AAOD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAQrD;AAiCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAK9C"}

package/dist/layout/dot/splines-route-type.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Edge-type dispatch for regular (cross-rank) edge routing.
+ *
+ * `make_regular_edge` routes the box corridor through `routesplines` for
+ * `EDGETYPE_SPLINE` and `routepolylines` otherwise; for `EDGETYPE_LINE` it
+ * additionally straightens a polyline of more than 4 points down to a 4-point
+ * line (first/last control points only). This module is the single home for
+ * that dispatch + straighten, called by every box-corridor emit point.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (1799-1808, 1849-1861)
+ */
+import type { Point } from '../../model/geom.js';
+import type { Path } from '../../common/types.js';
+/**
+ * Route the box corridor in `P` according to the edge type `et`.
+ *
+ * - `EDGETYPE_SPLINE` → `routeSplines` (the default; identical to before).
+ * - any other type → `routePolylines`.
+ * - `EDGETYPE_LINE` with a result of more than 4 points → straighten to the
+ *   4-point line `[p0, p0, pLast, pLast]`.
+ *
+ * Returns the control points, or `null`/empty exactly as the underlying
+ * `routeSplines`/`routePolylines` do (the caller treats that as a decline).
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ */
+export declare function routeRegularByType(P: Path, et: number): Point[] | null;
+//# sourceMappingURL=splines-route-type.d.ts.map

package/dist/layout/dot/splines-route-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-route-type.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-route-type.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAIlD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,IAAI,CAWtE"}

package/dist/layout/dot/splines-route.d.ts

@@ -0,0 +1,99 @@
+/**
+ * make_regular_edge and helpers — regular (non-flat) edge spline routing.
+ *
+ * Full pathplan routing is deferred until pathplan.ts is ported.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ */
+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 { splineMerge } from './splines.js';
+/**
+ * Per-call spline routing state (mirrors spline_info_t in C).
+ * @see lib/dotgen/dotsplines.c:spline_info_t
+ */
+export interface SplineInfo {
+    leftBound: number;
+    rightBound: number;
+    splinesep: number;
+    multisep: number;
+    rankBox: Box[];
+}
+export declare function nodeOutSize(n: Node): number;
+export declare function nodeInSize(n: Node): number;
+export declare function nodeType(n: Node): number;
+/** @see lib/dotgen/dotsplines.c:top_bound */
+export declare function topBound(e: Edge, side: number): Edge | undefined;
+/** @see lib/dotgen/dotsplines.c:bot_bound */
+export declare function botBound(e: Edge, side: number): Edge | undefined;
+/** True if v can continue a straight run from anchor n. */
+export declare function isStraightContinuation(v: Node, n: Node): boolean;
+/** Advance one step along the straight chain; return undefined if done. */
+export declare function straightNext(v: Node): Node | undefined;
+/** @see lib/dotgen/dotsplines.c:straight_len */
+export declare function straightLen(n: Node): number;
+/**
+ * Advance `cnt` head-out hops along the straight run from `e`, then append two
+ * copies of `pts`'s last point — emitting the straight middle of a smode
+ * segment as a degenerate (collinear) bezier piece. Mutates `pts` (+2 entries,
+ * each a value-copy of the prior last point, matching C's pointf-by-value
+ * appends); returns the edge `cnt` hops downstream.
+ * @see lib/dotgen/dotsplines.c:straight_path
+ */
+export declare function straightPath(e: Edge, cnt: number, pts: Point[]): Edge;
+/** @see lib/dotgen/dotsplines.c:resize_vn */
+export declare function resizeVn(vn: Node, lx: number, cx: number, rx: number): void;
+/** True if na/nb ordering contradicts expected crossing order. */
+export declare function orderContradicts(na: Node, nb: Node, order: boolean): boolean;
+/** Advance one step along out-edges of na and nb simultaneously. */
+export declare function advanceOutPair(e0: Edge | undefined, ef: Edge | undefined): [Edge | undefined, Edge | undefined];
+/** Advance one step along in-edges of na and nb simultaneously. */
+export declare function advanceInPair(e0: Edge | undefined, ef: Edge | undefined): [Edge | undefined, Edge | undefined];
+/** Check one out-step for a crossing. Returns true if crossing found. */
+export declare function outStepCrosses(e0: Edge, ef: Edge, order: boolean): boolean;
+/** Check one in-step for a crossing. Returns true if crossing found. */
+export declare function inStepCrosses(e0: Edge, ef: Edge, order: boolean): boolean;
+/** @see lib/dotgen/dotsplines.c:pathscross (out direction) */
+export declare function checkOutCross(n0: Node, order: boolean, e1: Edge | undefined): boolean;
+/** @see lib/dotgen/dotsplines.c:pathscross (in direction) */
+export declare function checkInCross(n0: Node, order: boolean, e1: Edge | undefined): boolean;
+/** @see lib/dotgen/dotsplines.c:pathscross */
+export declare function pathscross(n0: Node, n1: Node, ie1: Edge | undefined, oe1: Edge | undefined): boolean;
+/** True if n should be returned as a neighbor candidate. */
+export declare function isNeighborCandidate(n: Node): boolean;
+/** @see lib/dotgen/dotsplines.c:neighbor */
+export declare function neighbor(g: Graph, vn: Node, ie: Edge | undefined, oe: Edge | undefined, dir: number): Node | undefined;
+/**
+ * Apply x-offset to interior control points of a bezier (any length).
+ * C shifts only k=1..size-2 (interior control points).
+ * Endpoints (index 0 and index length-1) are fixed.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (pointfs interior shift)
+ */
+export declare function shiftInteriorPts(pts: Point[], dx: number): Point[];
+/**
+ * Route a group of cnt >= 1 parallel regular edges with C-faithful x-offsets.
+ *
+ * Algorithm (mirrors make_regular_edge cnt > 1 section in dotsplines.c):
+ *   1. Route one base path via rank-corridor spline.
+ *   2. dx = Multisep * (cnt - 1) / 2
+ *   3. edge[0]: interior points shifted left by dx
+ *   4. edge[j] (j=1..cnt-1): shift right by Multisep per step
+ *   Each shifted path is clipped to node boundaries independently.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ */
+export declare function routeParallelEdgeGroup(g: Graph, edges: Edge[], multisep: number): void;
+export { splineMerge };
+/**
+ * Direct tail→head line for a multi-rank `EDGETYPE_LINE` edge: a 4-point line
+ * (or 7-point through the edge label). Returns null to decline — `delr === 1`,
+ * or `delr === 2` when the graph carries edge labels — so the box-corridor path
+ * (which straightens its polyline) handles those cases instead.
+ *
+ * @see lib/dotgen/dotsplines.c:makeLineEdge (1636)
+ */
+export declare function makeLineEdge(g: Graph, fe: Edge): Point[] | null;
+//# sourceMappingURL=splines-route.d.ts.map

package/dist/layout/dot/splines-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splines-route.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/splines-route.ts"],"names":[],"mappings":"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"}