@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,99 @@
+/**
+ * Spline routing helpers: rank-corridor construction, Bezier clipping,
+ * and the two routing strategies (rank-aware and simple fallback).
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ * @see lib/common/routespl.c:routesplines_
+ * @see lib/common/splines.c:clip_and_install
+ */
+import type { Point } from '../../model/geom.js';
+import type { NodeBox } from './edge-route-geom.js';
+import { makeTailBox } from './edge-route-boxes.js';
+/** Result of computing a straight-line edge spline. */
+export interface EdgeSplineResult {
+    bezierPts: Point[];
+    arrowTip: Point;
+    arrowDir: Point;
+}
+/** Rank geometry needed to route an edge between two adjacent ranks. */
+export interface RankEdgeInfo {
+    leftBound: number;
+    rightBound: number;
+    tailHt1: number;
+    tailHt2: number;
+    headHt1: number;
+    headHt2: number;
+}
+/**
+ * Build the three-box corridor (tail, rank-gap, head) and start/end points.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (box assembly section)
+ */
+/**
+ * Resolved edge-port routing data, attached to the active router when an edge
+ * declares a tail/head port. A `null` end falls back to the node-center clip;
+ * a present point pins the spline to `node.coord + port.p`. `clip{Tail,Head}`
+ * mirror `port.clip` — false means the port point is exact and the node-boundary
+ * clip is skipped. @see lib/common/splines.c:beginpath (port offset + clip flag)
+ */
+export interface PortRoute {
+    tailP: Point | null;
+    headP: Point | null;
+    clipTail: boolean;
+    clipHead: boolean;
+}
+/** Whether to clip the spline to the tail/head node boundary. */
+export interface ClipFlags {
+    tail: boolean;
+    head: boolean;
+}
+export declare function buildRankCorridor(tailBox: NodeBox, headBox: NodeBox, rank: RankEdgeInfo, ports?: {
+    tailP: Point | null;
+    headP: Point | null;
+}): {
+    startPt: Point;
+    endPt: Point;
+    boxes: ReturnType<typeof makeTailBox>[];
+};
+/**
+ * Clip a routed Bezier to both node boundaries and extract arrow geometry.
+ * @see lib/common/splines.c:bezier_clip
+ */
+/**
+ * Arrow length for "normal" arrowhead (matching C's arrow_length_normal).
+ *
+ * Derived from miter_shape geometry for the normal (triangular) arrowhead:
+ *   arrowwidth = 0.35, half-angle theta/2 = arctan(arrowwidth)
+ *   miter_length l = penwidth/2 / tan(theta/2) = penwidth / (2*arrowwidth)
+ *   delta_tip.x = -penwidth * sqrt(1 + arrowwidth^2) / (2*arrowwidth)
+ *   full_length = ARROW_LENGTH - delta_tip.x + penwidth/2
+ *   overlap = penwidth/2
+ *   elen = full_length - overlap = ARROW_LENGTH + penwidth*sqrt(1+arrowwidth^2)/(2*arrowwidth)
+ *
+ * @see lib/common/arrows.c:arrow_length_normal
+ * @see lib/common/arrows.c:miter_shape
+ * @see lib/common/arrows.c:arrow_type_normal0
+ */
+export declare function normalArrowLen(penwidth?: number): number;
+/**
+ * Clip a routed Bezier to both node boundaries, then apply arrowEndClip
+ * to trim the path to the arrowhead BASE (not the node boundary).
+ * @see lib/common/splines.c:clip_and_install
+ * @see lib/common/arrows.c:arrowEndClip
+ */
+export declare function nodeInsideFn(box: NodeBox): (lx: number, ly: number) => boolean;
+export declare function clipToNodes(bezier: Point[], tailBox: NodeBox, headBox: NodeBox, penwidth?: number, clip?: ClipFlags): {
+    clipped: Point[];
+    arrowTip: Point;
+    arrowDir: Point;
+};
+/**
+ * Route edge through the rank-gap corridor using polygon-based spline fitting.
+ * @see lib/common/routespl.c:routesplines_
+ */
+export declare function routeWithRank(tailBox: NodeBox, headBox: NodeBox, rank: RankEdgeInfo, penwidth?: number, port?: PortRoute): EdgeSplineResult;
+/**
+ * Boundary-clip fallback when no rank geometry is available.
+ * @see lib/dotgen/dotsplines.c:make_regular_edge (straight-line fallback)
+ */
+export declare function routeSimple(tailBox: NodeBox, headBox: NodeBox, routeBezierFn: (from: Point, to: Point) => Point[]): EdgeSplineResult;
+//# sourceMappingURL=edge-route-routing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route-routing.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route-routing.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAIjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGpD,OAAO,EACL,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAM/B,uDAAuD;AACvD,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,KAAK,EAAE,CAAC;IACnB,QAAQ,EAAE,KAAK,CAAC;IAChB,QAAQ,EAAE,KAAK,CAAC;CACjB;AAED,wEAAwE;AACxE,MAAM,WAAW,YAAY;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAQD;;;GAGG;AACH;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,iEAAiE;AACjE,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf;AAID,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,YAAY,EAClB,KAAK,CAAC,EAAE;IAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;CAAE,GACnD;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,EAAE,CAAA;CAAE,CAe3E;AAOD;;;GAGG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,QAAQ,SAAuB,GAAG,MAAM,CAGtE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,OAAO,GACX,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAOrC;AAED,wBAAgB,WAAW,CACzB,MAAM,EAAE,KAAK,EAAE,EACf,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,QAAQ,SAAuB,EAC/B,IAAI,GAAE,SAAqB,GAC1B;IAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,KAAK,CAAA;CAAE,CAexD;AAOD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,YAAY,EAClB,QAAQ,SAAuB,EAC/B,IAAI,CAAC,EAAE,SAAS,GACf,gBAAgB,CASlB;AAOD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,KAAK,KAAK,EAAE,GACjD,gBAAgB,CAalB"}

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

@@ -0,0 +1,57 @@
+/**
+ * Edge spline routing orchestration for dot layout.
+ *
+ * Top-level entry point. Wires together the sub-modules (geom, clip,
+ * poly, boxes, routing, rank, helpers, chain) to compute and install
+ * Bezier splines and arrowhead polygons on every edge in the graph.
+ *
+ * @see lib/dotgen/dotsplines.c:make_regular_edge
+ * @see lib/common/splines.c:clip_and_install
+ * @see lib/common/routespl.c:routesplines_
+ * @see lib/common/arrows.c:arrow_type_normal
+ */
+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';
+export { normalizeVec, negateVec, offsetPoint, clipToNodeBox } from './edge-route-geom.js';
+export type { NodeBox } from './edge-route-geom.js';
+export { xClipT, yClipT } from './edge-route-geom.js';
+export { bezierClipNode, makeBoxInsideFn, bezierSubdivide, tailArrowEndClip, } from './edge-route-clip.js';
+export { boxesToPolygon, addForwardPolyPts, addReversePolyPts, polyEdgesFromPts, computeSpline, } from './edge-route-poly.js';
+export { makeTailBox, makeHeadBox, makeMaximalBbox, makeRankBox } from './edge-route-boxes.js';
+export type { RankBoxParams } from './edge-route-boxes.js';
+export { buildRankCorridor, clipToNodes, routeWithRank, routeSimple, normalArrowLen, } from './edge-route-routing.js';
+export type { EdgeSplineResult, RankEdgeInfo } from './edge-route-routing.js';
+export { computeLeftBound, computeRightBound, rankHt, rankEdgeInfoOf, getSplineBounds, resetSplineBounds, } from './edge-route-rank.js';
+export type { SplineBoundsSnapshot } from './edge-route-rank.js';
+export { ARROW_LENGTH, ARROW_WIDTH_FACTOR, arrowheadPolygon } from './edge-route-arrow.js';
+export { nodeBoxOf, edgeRenderPenwidth, edgePenwidthAttr, makeBezierRecord, makeSplineRecord, installEdgeSpline, routeBezier, straightEdgeSplineWithRank, } from './edge-route-helpers.js';
+export { routeBackEdge, } from './edge-route-chain.js';
+/** Straight-line cubic Bezier at 1/3 and 2/3. @see lib/dotgen/dotsplines.c */
+export declare function buildLinearBezier(p0: Point, p3: Point): Point[];
+/** Compute normalized tail→head direction between two node boxes. */
+export declare function edgeDirection(tailBox: NodeBox, headBox: NodeBox): Point;
+/** True when both endpoints have defined coordinates. */
+export declare function coordsDefined(e: GraphEdge): boolean;
+/** True when both endpoints sit at the origin (un-initialised). */
+export declare function bothAtOrigin(e: GraphEdge): boolean;
+/** True when the edge's endpoints have usable coordinates. */
+export declare function hasValidCoords(e: GraphEdge): boolean;
+/** Route and install spline + arrowhead(s) for a single edge. */
+export declare function routeOneEdge(e: GraphEdge, g: Graph): void;
+/**
+ * Compute and install edge splines for all unrouted edges in g.
+ * @see lib/dotgen/dotsplines.c:dot_splines_
+ */
+/**
+ * Route one not-yet-routed edge, applying the `dot_splines_` skip guards. No-op
+ * if the edge is already routed or ineligible (FLATORDER/IGNORED, self-loop, or
+ * lacking valid coords). Used both by the unified `dotSplines_` loop — which
+ * routes lone edges at their `edgecmp` position, interleaved with groups, as C
+ * does — and by the `routeDotEdges` backstop sweep below.
+ * @see lib/dotgen/dotsplines.c:dot_splines_ (per-edge dispatch + 295 skip)
+ */
+export declare function routeLoneEdge(e: GraphEdge, g: Graph): void;
+export declare function routeDotEdges(g: Graph): void;
+//# sourceMappingURL=edge-route.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"edge-route.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/edge-route.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,IAAI,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AA4CpD,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC3F,YAAY,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EACL,cAAc,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,GACnE,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,cAAc,EAAE,iBAAiB,EAAE,iBAAiB,EACpD,gBAAgB,EAAE,aAAa,GAChC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAC/F,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EACL,iBAAiB,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAC1D,cAAc,GACf,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,EACL,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,EAC3D,eAAe,EAAE,iBAAiB,GACnC,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAG3F,OAAO,EACL,SAAS,EAAE,kBAAkB,EAAE,gBAAgB,EAC/C,gBAAgB,EAAE,gBAAgB,EAAE,iBAAiB,EACrD,WAAW,EAAE,0BAA0B,GACxC,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,aAAa,GACd,MAAM,uBAAuB,CAAC;AAM/B,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,KAAK,EAAE,CAE/D;AAMD,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,KAAK,CAKvE;AAMD,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEnD;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAIlD;AAED,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,GAAG,OAAO,CAEpD;AAmHD,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CAmBzD;AAkLD;;;GAGG;AACH;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CAuB1D;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAE5C"}

package/dist/layout/dot/fastgr.d.ts

@@ -0,0 +1,147 @@
+/**
+ * TypeScript port of lib/dotgen/fastgr.c.
+ *
+ * Maintains the "fast graph" — compact mutation-friendly adjacency lists
+ * layered on top of the cgraph model, used during cycle-breaking and
+ * virtual-node construction.
+ *
+ * @see lib/dotgen/fastgr.c
+ */
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { Port } from '../../model/geom.js';
+import type { EdgeList } from '../../model/nodeInfo.js';
+import type { Graph } from '../../model/graph.js';
+/** Virtual edge type. @see lib/common/types.h */
+export declare const VIRTUAL = 1;
+/** Normal edge type. @see lib/common/types.h */
+export declare const NORMAL = 0;
+/** Flat ordering constraint edge type. @see lib/common/const.h */
+export declare const FLATORDER = 4;
+/** Reversed flat edge type. @see lib/common/const.h */
+export declare const REVERSED = 3;
+/** Scale factor for median computation. @see lib/dotgen/mincross.c:MC_SCALE */
+export declare const MC_SCALE = 256;
+/**
+ * Return el if defined, otherwise a fresh empty EdgeList.
+ * @see lib/dotgen/fastgr.c (implicit in elist operations)
+ */
+export declare function ensureList(el: EdgeList | undefined): EdgeList;
+/**
+ * Append edge `e` to list — `L.list[L.size++] = e`.
+ * @see lib/dotgen/fastgr.c:elistAppend
+ */
+export declare function elistAppend(el: EdgeList, e: Edge): void;
+/**
+ * Swap-last-remove of edge `e` from `el`.
+ * Uses while+&& to scan, then a single conditional swap.
+ * @see lib/dotgen/fastgr.c:zapinlist
+ */
+export declare function zapinlist(el: EdgeList, e: Edge): void;
+/**
+ * Remove `e` from the fast graph (tail.out and head.in).
+ * @see lib/dotgen/fastgr.c:deleteFastEdge
+ */
+export declare function deleteFastEdge(e: Edge): void;
+/**
+ * Add `e` to the fast graph (tail.out and head.in).
+ * @see lib/dotgen/fastgr.c:fastEdge
+ */
+export declare function fastEdge(e: Edge): void;
+/**
+ * Search for an existing fast edge from `u` to `v`.
+ * Inlines the static `ffe` helper from C: searches the smaller list.
+ * @see lib/dotgen/fastgr.c:findFastEdge
+ * @see lib/dotgen/fastgr.c:ffe
+ */
+export declare function findFastEdge(u: Node, v: Node): Edge | undefined;
+export declare function copyPort(p: Port): Port;
+/**
+ * Port copy is direction-aware: a reversed virtual edge takes the
+ * orig's opposite-end port.
+ * @see lib/dotgen/fastgr.c:new_virtual_edge
+ */
+export declare function copyVirtualPorts(e: Edge, orig: Edge): void;
+/** Copy weights, ports, and labels from orig; link to_virt/to_orig. */
+export declare function copyVirtualEdgeInfo(e: Edge, orig: Edge): void;
+/**
+ * Allocate a virtual edge from `u` to `v`, copying port/label info from `orig`.
+ * `orig` may be null when called from do_ordering_node (C passes NULL there).
+ * @see lib/dotgen/fastgr.c:new_virtual_edge
+ */
+export declare function newVirtualEdge(u: Node, v: Node, orig: Edge | null): Edge;
+/**
+ * Create a virtual edge and register it in the fast graph.
+ * @see lib/dotgen/fastgr.c:virtualEdge
+ */
+export declare function virtualEdge(u: Node, v: Node, orig: Edge): Edge;
+export declare function mergeWeightsInto(f: Edge, ew: number, em: number, ex: number): void;
+export declare function basicMerge(e: Edge, rep: Edge): void;
+/**
+ * Merge edge `e` into representative `rep`, accumulating weights.
+ * @see lib/dotgen/fastgr.c:mergeOneway
+ */
+export declare function mergeOneway(e: Edge, rep: Edge): void;
+/**
+ * Remove `e` from the flat graph (tail.flat_out and head.flat_in).
+ * Also clears `e.info.to_virt` back-reference.
+ * @see lib/dotgen/fastgr.c:delete_flat_edge
+ */
+export declare function deleteFlatEdge(e: Edge): void;
+/**
+ * Add `e` to the flat graph (tail.flat_out and head.flat_in) and mark the
+ * graph as having flat edges.
+ * @see lib/dotgen/fastgr.c:flat_edge
+ */
+export declare function flatEdge(g: import('../../model/graph.js').Graph, e: Edge): void;
+/**
+ * Search for an existing flat edge from `u` to `v`.
+ * @see lib/dotgen/fastgr.c:find_flat_edge
+ */
+export declare function findFlatEdge(u: import('../../model/node.js').Node, v: import('../../model/node.js').Node): Edge | undefined;
+/**
+ * Reverse edge `e`: remove from fast graph, then merge into or create a
+ * reverse virtual edge. Sets `e.info.reversed` for dot_splines orientation.
+ * @see lib/dotgen/acyclic.c:reverse_edge
+ */
+export declare function reverseEdge(e: Edge): void;
+/**
+ * Add node `n` to graph `g`'s fast-graph linked list (nlist).
+ * @see lib/dotgen/fastgr.c:fast_node
+ */
+export declare function fastNode(g: Graph, n: Node): void;
+/**
+ * Remove node `n` from graph `g`'s fast-graph linked list.
+ * @see lib/dotgen/fastgr.c:delete_fast_node
+ */
+export declare function deleteFastNode(g: Graph, n: Node): void;
+/**
+ * Remove node `n` from its rank's ordered node list `v[]`, shifting later
+ * entries down one and decrementing the rank's count. The structural inverse
+ * of install_in_rank / placeInRankSlot.
+ *
+ * Faithful to the C: the scan starts at index 0 (not vStart). For the common
+ * single-component case vStart is 0/undefined, matching C's index-from-0 scan.
+ * @see lib/dotgen/dotinit.c:remove_from_rank
+ */
+export declare function removeFromRank(g: Graph, n: Node): void;
+/**
+ * Allocate a virtual (VIRTUAL node_type) node, add it to `g`'s fast graph
+ * with pre-allocated in/out edge lists of capacity 4.
+ *
+ * `n.root` is bound to `g.root` (agroot(g)), NOT `g` itself, mirroring the
+ * cgraph invariant every node's root points to the absolute top graph, never
+ * an enclosing cluster subgraph — even when `g` here is a cluster. C:
+ * `n->root = agroot(g);` (fastgr.c:204). Binding root to the cluster instead
+ * left cluster-owned virtual (label) nodes without a populated info.flip
+ * (clusters never run initSubgraphRankdir), corrupting flip-dependent reads
+ * such as placeVnlabel's labelXPos (splines-label.ts).
+ * @see lib/dotgen/fastgr.c:virtual_node
+ */
+export declare function virtualNode(g: Graph): Node;
+/**
+ * Append edge `e` to the `other` list of its tail node.
+ * @see lib/dotgen/fastgr.c:other_edge
+ */
+export declare function otherEdge(e: Edge): void;
+//# sourceMappingURL=fastgr.d.ts.map

package/dist/layout/dot/fastgr.d.ts.map

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

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

@@ -0,0 +1,21 @@
+/**
+ * Safe field accessors for flat.ts.
+ *
+ * Kept in a separate file because lizard 1.22.1 mis-parses TypeScript when
+ * many function definitions accumulate in one file, inflating CCN counts for
+ * unrelated functions. Splitting accessors here avoids the parse bug.
+ *
+ * @see lib/dotgen/flat.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { RankEntry } from '../../model/rankEntry.js';
+export declare function nodeOrder(n: Node): number;
+export declare function nodeRank(n: Node): number;
+export declare function graphNodesep(g: Graph): number;
+export declare function graphMaxrank(g: Graph): number;
+export declare function graphMinrank(g: Graph): number;
+export declare function graphNCluster(g: Graph): number;
+/** Read order field of rank slot i safely. */
+export declare function getOrd(rk: RankEntry, i: number): number;
+//# sourceMappingURL=flat-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flat-utils.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/flat-utils.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,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAGzC;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAGxC;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAG7C;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAG7C;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAG7C;AAED,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAG9C;AAED,8CAA8C;AAC9C,wBAAgB,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvD"}

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

@@ -0,0 +1,152 @@
+/**
+ * TypeScript port of lib/dotgen/flat.c.
+ *
+ * Handles labeled flat (same-rank) edges: virtual node insertion into rank
+ * arrays, label-node slot allocation, and the abomination rank-array shift
+ * when labeled flat edges fall at rank 0.
+ *
+ * Note: all functions are exported because lizard 1.22.1's TypeScript parser
+ * only recognises function boundaries when the `export` keyword is present.
+ * Non-exported TS functions with return-type annotations cause the parser to
+ * merge them into the preceding function's body, inflating CCN counts.
+ *
+ * @see lib/dotgen/flat.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { RankEntry } from '../../model/rankEntry.js';
+import type { EdgeList } from '../../model/nodeInfo.js';
+import type { TextlabelT } from '../../common/types.js';
+export declare function shiftSlotRight(rk: RankEntry, pos: number): void;
+/**
+ * Insert a virtual node slot at position `pos` in rank `r` of graph `g`.
+ * @see lib/dotgen/flat.c:make_vn_slot
+ */
+export declare function makeVnSlot(g: Graph, r: number, pos: number): Node;
+/** Sorted [lo, hi] of the orders of u and v. @see lib/dotgen/flat.c:findlr */
+export declare function findlr(u: Node, v: Node): [number, number];
+/** A flat label vnode (no in-edges): bound by where its two endpoints sit
+ *  relative to [lpos,rpos]. @see lib/dotgen/flat.c:setbounds (flat branch) */
+export declare function setBoundsFlat(v: Node, bounds: number[], lpos: number, rpos: number): void;
+/** A forward chain vnode (has in-edges): hard-bound by whether all its
+ *  downstream connections fall left or right of the span.
+ *  @see lib/dotgen/flat.c:setbounds (forward branch) */
+export declare function setBoundsForward(v: Node, bounds: number[], lpos: number, rpos: number): void;
+/** Update label-placement bounds from one rank-(r-1) node `v`, given the flat
+ *  edge's endpoint-order span [lpos,rpos] on rank r. @see lib/dotgen/flat.c:setbounds */
+export declare function setBounds(v: Node, bounds: number[], lpos: number, rpos: number): void;
+/**
+ * Find the best order position for a flat-edge label virtual node in rank r-1.
+ * Faithful port of C's bound-scan (NOT a simple order comparison).
+ * @see lib/dotgen/flat.c:flat_limits
+ */
+export declare function flatLimits(g: Graph, e: Edge): number;
+export declare function graphRanksep(g: Graph): number;
+/**
+ * ypos = LL.y of the label box, grabbed before make_vn_slot so the new slot does
+ * not perturb it. @see lib/dotgen/flat.c:flat_node 154-159
+ */
+export declare function flatLabelYpos(g: Graph, r: number): number;
+/**
+ * Set ht/lw/rw on the label vnode from the label dimen (flip swaps x/y); return
+ * half-height. @see lib/dotgen/flat.c:flat_node 161-167
+ */
+export declare function flatNodeDims(g: Graph, vn: Node, lbl: TextlabelT): number;
+/**
+ * Create the two FLATORDER virtual edges (vn→tail, vn→head) with label ports.
+ * @see lib/dotgen/flat.c:flat_node 170-177
+ */
+export declare function flatNodeEdges(vn: Node, e: Edge): void;
+/**
+ * Create a VIRTUAL label node (ND_alg → e) above a non-adjacent flat edge.
+ *
+ * `g` is the graph being laid out. C reads it as `dot_root(agtail(e))`, which is
+ * `GD_dotroot(agroot(e))` — a MUTABLE slot on the cgraph root that `dot_init_subg`
+ * re-points at the graph currently being laid out. It is therefore NOT the same as
+ * `agroot(agtail(e))`: under `pack`, each connected component is laid out as its own
+ * dot-root, so `dot_root()` yields the COMPONENT while `agroot()` yields the true
+ * root (which has no rank table at all). The port has no such mutable slot, so the
+ * layout graph is threaded in from `flat_edges` — which is exactly what C's
+ * `dot_root()` evaluates to at every call site here.
+ *
+ * @see lib/dotgen/flat.c:flat_node (g = dot_root(agtail(e)))
+ * @see lib/dotgen/dotinit.c:dot_init_subg (GD_dotroot(agroot(g)) = droot)
+ */
+export declare function flatNode(g: Graph, e: Edge): void;
+/** Fresh empty rank entry (the slot vacated by the +1 renumber). */
+export declare function emptyRankEntry(): RankEntry;
+/**
+ * Shift a cluster subtree's absolute-rank-indexed state to follow the +1
+ * renumber performed by `abomination` (AD-2).
+ *
+ * C needs no such pass: its abomination adds the label rank at index -1
+ * (`GD_rank(g) = rptr + 1`, `GD_minrank(g)--`) and never touches ND_rank, so a
+ * cluster's GD_minrank/GD_maxrank, GD_rank(clust)[] and GD_rankleader(clust)[]
+ * — all indexed by ABSOLUTE rank — stay correct. JS has no negative index, so
+ * the port renumbers +1 instead, and every absolute-rank-indexed structure has
+ * to move with it. Skipping the clusters leaves them pointing one rank too low:
+ * the next step of flat_edges (rec_reset_vlists → reset_vlist) re-aliases
+ * GD_rank(clust)[r].v = GD_rank(root)[r].v at the cluster's stale r, which now
+ * addresses the newly inserted flat-label rank instead of the cluster's own.
+ *
+ * @see lib/dotgen/flat.c:abomination
+ * @see lib/dotgen/mincross.c:reset_vlist
+ */
+export declare function shiftClusterRanks(g: Graph): void;
+/** Make room for a flat label vnode below the lowest rank (name from C; AD-2).
+ * @see lib/dotgen/flat.c:abomination */
+export declare function abomination(g: Graph): void;
+export declare function hasInterveningNode(rk: RankEntry, lo: number, hi: number): boolean;
+/**
+ * Mark flat edge as adjacent if no nodes fall between its endpoints in rank.
+ * When adjacent, C marks the edge AND every edge in its `to_virt` chain (the
+ * `do { ED_adjacent(e)=1; e=ED_to_virt(e); } while(e)` loop): the class rep must
+ * carry the flag too, because flat_edges' `other`-loop copies adjacency from the
+ * rep (`ED_adjacent(e) = ED_adjacent(le)`). Marking only the leaf left the rep
+ * unmarked, so that copy clobbered the flag back to 0 and the edge mis-routed
+ * through the generic fitter (a spurious y-slope on a flat edge).
+ *
+ * `g` is the graph being laid out — C's `dot_root(tn)`, NOT `agroot(tn)`. See
+ * `flatNode` above for why these differ under `pack`.
+ *
+ * @see lib/dotgen/flat.c:checkFlatAdjacent (rank = &GD_rank(dot_root(tn))[...])
+ */
+export declare function checkFlatAdjacent(g: Graph, e: Edge): void;
+export declare function isLabeledFlat(e: Edge): boolean;
+export declare function markEdgeList(g: Graph, edges: EdgeList | undefined): void;
+export declare function markAdjacent(g: Graph): void;
+export declare function rankHasNonAdjacentLabel(rk: RankEntry): boolean;
+/**
+ * AD-1: C gates this on `GD_rank(g)[0].flat || GD_n_cluster(g) > 0` and then
+ * scans for a labeled non-adjacent flat edge on rank mn. In this port the
+ * `rank[mn].flat` adjacency matrix is unreliable at position-time (mincross
+ * builds it before `flat_out` is populated), so we detect the rank-mn labeled
+ * non-adjacent flat edge directly via `flat_out` — which is the real gate. This
+ * only fires for a graph with such an edge on the lowest rank (none of the 115
+ * goldens have one), so it is byte-safe. @see lib/dotgen/flat.c:flat_edges 279
+ */
+export declare function needsAbomination(g: Graph): boolean;
+/** Store the representative's flat-label width directly. @see flat.c:300 */
+export declare function applyLabelDist(g: Graph, e: Edge): void;
+/** flat_out loop body: store label dist on e (the rep), or add a label vnode.
+ *  @see lib/dotgen/flat.c:flat_edges 296-307 */
+export declare function processFlatOutLabel(g: Graph, e: Edge, reset: boolean): boolean;
+/** other loop body: inherit adjacency from the class rep, and for an adjacent
+ *  labeled edge MAX its label width onto the rep's dist (not the edge itself);
+ *  non-adjacent labeled edges add a label vnode. Skips cross-rank and self
+ *  edges. @see lib/dotgen/flat.c:flat_edges 309-326 */
+export declare function processOtherLabel(g: Graph, e: Edge, reset: boolean): boolean;
+/**
+ * The flat_edges dist/label-vnode pass. C nests BOTH the flat_out and other
+ * loops inside `if (ND_flat_out(n).list)`, so a node with no flat_out processes
+ * neither. @see lib/dotgen/flat.c:flat_edges 288-330
+ */
+export declare function processNodes(g: Graph): boolean;
+/**
+ * Process flat edges for label placement and abomination.
+ * Returns true if rank arrays were modified (label nodes inserted).
+ * @see lib/dotgen/flat.c:flat_edges
+ */
+export declare function flatEdges(g: Graph): boolean;
+//# sourceMappingURL=flat.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+/**
+ * Cluster label dimension setup for dot layout.
+ *
+ * @see lib/common/input.c:do_graph_label
+ */
+import type { Graph } from '../../model/graph.js';
+import type { TextMeasurer } from '../../common/textmeasure.js';
+/** Graph has a label. @see lib/common/const.h:GRAPH_LABEL */
+export declare const GRAPH_LABEL: number;
+/**
+ * Compute cluster label dimensions and set sg.info.border so that clustHt
+ * accounts for label height.
+ *
+ * @see lib/common/input.c:do_graph_label
+ * @see lib/common/input.c:850 — make_label(sg, str, aghtmlstr(str), false, ...)
+ */
+export declare function doGraphLabel(sg: Graph, measurer: TextMeasurer | undefined): void;
+//# sourceMappingURL=graph-label.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph-label.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/graph-label.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAElD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE,6DAA6D;AAC7D,eAAO,MAAM,WAAW,QAAS,CAAC;AAmElC;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAuBhF"}