@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,128 @@
+/**
+ * Dot layout engine entry point.
+ *
+ * Wires together the full dot layout pipeline:
+ *   setAspect → dotInitSubg → dotInitNodeEdge →
+ *   dotRank → dotMincross → dotPosition →
+ *   removeFill → dotSameports → dotSplines → dotCompoundEdges
+ *
+ * Also exports DOT_LAYOUT_ENGINE, the LayoutEngine registration object
+ * used by GvcContext.
+ *
+ * @see lib/dotgen/dotinit.c:dot_layout
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+import type { Graph } from '../../model/graph.js';
+import type { LayoutEngine } from '../../gvc/context.js';
+export { CL_CROSS, dotInitNode, dotInitEdge, dotInitSubg, dotInitNodeEdge, removeFill, dotCleanup, dotGraphInit, RANKDIR_TB, RANKDIR_LR, RANKDIR_BT, RANKDIR_RL, } from './init.js';
+/**
+ * Stores the edge-type flag in the low 4 bits of g.info.flags.
+ * Mirrors the C macro setEdgeType(g, t).
+ *
+ * @see lib/common/const.h:setEdgeType
+ */
+export declare function setEdgeType(g: Graph, t: number): void;
+/**
+ * Set the edge type from the graph's `splines` attribute: unset → defaultValue,
+ * empty string → NONE, otherwise the parsed value. Mirrors C's setEdgeType
+ * (which reads `agget(g, "splines")`). @see lib/common/utils.c:setEdgeType
+ *
+ * C's `agget` resolves a graph attribute up the ancestor chain, so a component
+ * subgraph sees the root's `splines`. The port's `attrs` map holds only the
+ * attributes written on that graph, so walk to the root ourselves — otherwise
+ * the per-component call sites (neato's `gc`, sfdp's `sg`) read `undefined` and
+ * silently fall back to the default.
+ */
+export declare function setEdgeTypeFromAttr(g: Graph, defaultValue: number): void;
+/**
+ * Reads an integer graph attribute, returning defaultVal if not set.
+ * Mirrors late_int() from lib/common/utils.c for graph-level reads.
+ *
+ * @see lib/common/utils.c:late_int
+ */
+export declare function getAttrInt(g: Graph, key: string, defaultVal: number): number;
+/**
+ * Phase 0: parse rankdir, set edge type, and run aspect + init passes.
+ * dotGraphInit must run first so g.info.flip is set before nodeinit uses it.
+ * @see lib/common/input.c:600-663 graph_init
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+export declare function dotPhaseInit(g: Graph): void;
+/**
+ * Phase 4a: post-position passes WITHOUT the final gvPostprocess —
+ * removeFill, sameports, splines, compound. This is C's static `dotLayout`
+ * tail; the per-component pack branch runs exactly this (gvPostprocess is run
+ * once on the root afterwards, not per component).
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ */
+export declare function dotPhasePostNoFinish(g: Graph): void;
+/**
+ * Phase 4: post-position passes — the no-finish tail plus gvPostprocess to
+ * rotate/translate coordinates per rankdir.
+ * @see lib/dotgen/dotinit.c:dotLayout (static)
+ * @see lib/common/postproc.c:dotneato_postprocess
+ */
+export declare function dotPhasePost(g: Graph): void;
+/**
+ * Runs the full dot layout pipeline on graph g.
+ *
+ * The optional `maxphase` attribute (read from g.attrs) controls how many
+ * phases run (1=rank only, 2=+mincross, 3=+position, ≥4 or absent=all).
+ *
+ * C's `dotLayout` checks `dot_mincross`'s return code and returns immediately
+ * on failure, skipping `dot_position` (phase 3) and `dotneato_postprocess`
+ * entirely — `dot_position` is never reached with a rank/cluster-window state
+ * that `dot_mincross` has already given up on (e.g. a cluster's rank window
+ * outliving root's rank-array allocation after malformed-input rankset
+ * recovery deletes cluster members but leaves the window unshrunk). The port
+ * previously discarded `dotMincross`'s return value and always ran
+ * `dotPosition` regardless, so `dotPosition` could observe exactly that
+ * unreachable-in-C state and crash (e.g. `position-ycoords.ts:clustHt`
+ * indexing the root rank array one past its allocated length).
+ * @see lib/dotgen/dotinit.c:dotLayout (static) — `if (rc != 0) return rc;`
+ *   after `dot_mincross`, propagated through `doDot`/`dot_layout` to also
+ *   skip `dotneato_postprocess`.
+ *
+ * C applies the identical `if (r != 0) return r;` check after `dot_position`
+ * (dotinit.c:322-325), also skipping `dotPhasePost` (removeFill/sameports/
+ * splines/compound) and `gvPostprocess`. `dot_position` fails when
+ * `dot_concentrate` fails (`rebuild_vlists: lead is null for rank N`, e.g.
+ * corpus 2825 — a cross-cluster rank=same plus rankset-conflict deletions
+ * leaves a cluster rank with no rankleader); C's renderer then walks the
+ * still-fully-connected `Agraph_t` but every node fails `node_in_box`
+ * against the never-computed (all-zero) `GD_bb`, so only cluster frames
+ * (also zero-sized, since `set_aspect`/cluster geometry never ran) reach
+ * the page. The port previously discarded `dotPosition`'s return value and
+ * always ran `dotPhasePost`, producing a full (non-degenerate) rendering
+ * where C produces near-empty output.
+ */
+export declare function dotLayoutPipeline(g: Graph): void;
+/**
+ * Port of C's `doDot`: when `pack`/`packmode` is set, decompose the graph into
+ * connected components, lay out each one, and polyomino-pack them; otherwise
+ * (and for a single component, or a non-R_NONE ratio) fall back to whole-graph
+ * `dotLayoutPipeline`. The thin component loop + cluster carry live in
+ * pack-components.ts (ADR-1). `dotLayoutPipeline` already includes the root
+ * `gvPostprocess`, so the simple arms map exactly to C's `dotLayout(g)` +
+ * `dotneato_postprocess(g)`; the pack arm runs `gvPostprocess` once inside
+ * `layoutAndPack`.
+ *
+ * @see lib/dotgen/dotinit.c:doDot
+ */
+export declare function doDot(g: Graph): void;
+/**
+ * LayoutEngine.layout implementation for the dot engine.
+ * Skips empty graphs (matching C's agnnodes(g) guard).
+ *
+ * @see lib/dotgen/dotinit.c:dot_layout
+ */
+export declare function dotLayoutEntry(g: Graph): void;
+/**
+ * The dot layout engine registration object.
+ * Register with GvcContext.register(DOT_LAYOUT_ENGINE).
+ *
+ * @see lib/gvc/gvplugin.h:gvlayout_engine_s
+ * @see lib/dotgen/dotinit.c:dot_layout
+ */
+export declare const DOT_LAYOUT_ENGINE: LayoutEngine;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/index.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAyBzD,OAAO,EACL,QAAQ,EACR,WAAW,EACX,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,GACX,MAAM,WAAW,CAAC;AAOnB;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAErD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAUxE;AAMD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAK5E;AAOD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAM3C;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAUnD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG3C;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAYhD;AAkBD;;;;;;;;;;;GAWG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CA4BpC;AAMD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG7C;AAMD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAI/B,CAAC"}

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

@@ -0,0 +1,93 @@
+/**
+ * TypeScript port of lib/dotgen/dotinit.c — initialisation helpers for
+ * the dot layout pipeline (dot_init_node, dot_init_edge, dot_init_subg,
+ * dot_init_node_edge, removeFill, dot_cleanup).
+ *
+ * @see lib/dotgen/dotinit.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+export { RANKDIR_TB, RANKDIR_LR, RANKDIR_BT, RANKDIR_RL } from '../../common/graph-init.js';
+/**
+ * dot's call into the engine-agnostic `graph_init`, plus the one piece of
+ * rankdir handling that is genuinely dot's: propagating GD_rankdir2 down to the
+ * clusters (C does this in dot's own `initSubg`, dotinit.c:352 — NOT in
+ * graph_init).
+ *
+ * dot is the only engine with `LAYOUT_USES_RANKDIR`
+ * (plugin/dot_layout/gvlayout_dot_layout.c:27), hence `useRankdir = true`: the
+ * effective rankdir (bits 0-1) tracks the attr instead of being pinned to TB.
+ *
+ * @see lib/common/input.c:600 graph_init
+ * @see lib/gvc/gvlayout.c:81 (graph_init(g, LAYOUT_USES_RANKDIR))
+ * @see lib/dotgen/dotinit.c:352 initSubg
+ */
+export declare function dotGraphInit(g: Graph): void;
+/**
+ * Crossing penalty for cluster-skeleton / same-group edges.
+ * C uses 1000 except under _WIN32, where 100 avoids a 16-bit overflow.
+ * The oracle platform (and every modern build) takes the 1000 branch;
+ * mincross best-order selection on penalty plateaus depends on it.
+ * @see lib/common/const.h:CL_CROSS
+ */
+export declare const CL_CROSS = 1000;
+/**
+ * Initialises per-node layout data for the dot engine.
+ * Mirrors dot_init_node: binds Agnodeinfo_t and allocates edge lists.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_node
+ */
+export declare function dotInitNode(n: Node): void;
+/**
+ * True when tail and head carry the same non-empty `group` attribute.
+ * C compares interned refstr pointers (`tailgroup == headgroup`); cgraph's
+ * per-graph string pool makes that exactly content equality, and the
+ * `tailgroup[0]` guard excludes the shared "" default.
+ * @see lib/dotgen/dotinit.c:dot_init_edge (tailgroup/headgroup check)
+ */
+export declare function sameNonemptyGroup(e: Edge): boolean;
+/**
+ * Initialises per-edge layout data for the dot engine.
+ * Mirrors dot_init_edge: sets weight, count, xpenalty, minlen.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_edge
+ */
+export declare function dotInitEdge(e: Edge): void;
+/**
+ * Recursively initialises subgraph-level attributes with defaults.
+ * Mirrors dot_init_subg: binds Agraphinfo_t and propagates params.
+ *
+ * nodesep defaults: 0.25 in × 72 = 18 pts; ranksep: 0.5 in × 72 = 36 pts.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_subg
+ */
+export declare function dotInitSubg(g: Graph): void;
+/**
+ * Calls commonInitNode (shape-aware, label-driven sizing) then
+ * dotInitNode for every node, then dotInitEdge for every edge.
+ *
+ * @see lib/dotgen/dotinit.c:dot_init_node_edge
+ * @see lib/dotgen/dotinit.c:dot_init_node (common_init_node + gv_nodesize)
+ */
+export declare function dotInitNodeEdge(g: Graph): void;
+/**
+ * Deletes the placeholder fill-nodes inserted by fillRanks (NEW_RANK mode)
+ * once positioning is done, so they never render. Looks up the `_new_rank`
+ * subgraph under the root graph; if absent (the common no-newrank case) this
+ * is a no-op. Operates on `g.root` throughout because fillRanks created the
+ * fill nodes and their ranks under the root.
+ *
+ * @see lib/dotgen/dotinit.c:removeFill
+ */
+export declare function removeFill(g: Graph): void;
+/**
+ * Clears all edge lists and linked-list pointers from nodes in the fast-graph,
+ * releasing layout state without destroying the underlying graph structure.
+ *
+ * Mirrors dot_cleanup: frees virtual node list then per-node edge lists.
+ *
+ * @see lib/dotgen/dotinit.c:dot_cleanup
+ */
+export declare function dotCleanup(g: Graph): void;
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/init.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;AAkBhD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAQ5F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAG3C;AAwBD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,OAAO,CAAC;AAM7B;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAgBzC;AAMD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAIlD;AAiCD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CA2BzC;AAMD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAQ1C;AAMD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAU9C;AAMD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAczC;AAMD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAczC"}

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

@@ -0,0 +1,45 @@
+/**
+ * checkLabelOrder / fixLabelOrder — correct the rank order of flat-edge label
+ * virtual nodes when it conflicts with their endpoint intervals, which would
+ * otherwise make dot_position's "label between its vertices" constraint
+ * infeasible. Ported from lib/dotgen/mincross.c:178-326.
+ *
+ * The per-rank auxiliary graph (C's Agstrictdirected `lg`/`sg`) is modelled as
+ * a small array of LabelNode with in/out adjacency (AD-2) — it is tiny and
+ * rebuilt per rank.
+ *
+ * @see lib/dotgen/mincross.c:fixLabelOrder, checkLabelOrder
+ */
+import type { Node } from '../../model/node.js';
+import type { Graph } from '../../model/graph.js';
+import type { RankEntry } from '../../model/rankEntry.js';
+/** Auxiliary node, one per flat-edge label vnode on a rank (mirrors info_t). */
+export interface LabelNode {
+    /** Lower endpoint order. @see ND_lo */
+    lo: number;
+    /** Upper endpoint order. @see ND_hi */
+    hi: number;
+    /** The dot label virtual node. @see ND_np */
+    np: Node;
+    /** Original rank order of np. @see ND_idx = ND_order(ND_np) */
+    idx: number;
+    /** DFS visited flag. @see ND_x */
+    x: number;
+    out: LabelNode[];
+    in: LabelNode[];
+}
+/**
+ * Reorder a rank's flat-label vnodes so their order is consistent with their
+ * endpoint intervals. Builds conflict edges, and for each connected component
+ * containing a backedge, reassigns np.order / rank.v[] to the topological order
+ * over the component's original positions.
+ * @see lib/dotgen/mincross.c:fixLabelOrder
+ */
+export declare function fixLabelOrder(nodes: LabelNode[], rank: RankEntry): void;
+/**
+ * For each rank, collect flat-edge label vnodes and, when a rank has more than
+ * one, run fixLabelOrder to repair an infeasible order.
+ * @see lib/dotgen/mincross.c:checkLabelOrder
+ */
+export declare function checkLabelOrder(g: Graph): void;
+//# sourceMappingURL=label-order.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"label-order.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/label-order.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,6CAA6C;IAC7C,EAAE,EAAE,IAAI,CAAC;IACT,+DAA+D;IAC/D,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,SAAS,EAAE,CAAC;IACjB,EAAE,EAAE,SAAS,EAAE,CAAC;CACjB;AAoED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,SAAS,GAAG,IAAI,CAevE;AAqBD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAW9C"}

package/dist/layout/dot/mincross-build.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Build-phase helpers for the mincross algorithm: rank allocation and filling,
+ * BFS rank installation, and edge-ordering setup. Flat-edge cycle breaking and
+ * flat reorder live in ./mincross-flat.js and are re-exported here.
+ * @see lib/dotgen/mincross.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 { MincrossContext } from './mincross-utils.js';
+import { installCluster, expandCluster, markLowclusters } from './cluster.js';
+export declare function betweenclust(e: Edge): boolean;
+export { flatRevFindRev, flatRev, flatSearchOstack, flatSearchNormal, flatSearchEdge, flatSearch, flatBreakcyclesRank, flatBreakcycles, constrainingFlatEdge, countConstraining, postorder, flatReorderBuildTemprank, flatReorderFixEdges, flatReorderRank, flatReorder, } from './mincross-flat.js';
+export declare function makeEmptyRank(): RankEntry;
+export declare function allocateRanksCount(g: Graph, cn: number[]): void;
+export declare function allocateRanks(g: Graph): void;
+/**
+ * Recursive cluster walk: fill empty ranks in `g` and its sub-clusters with
+ * placeholder nodes; returns the `_new_rank` subgraph (lazily created).
+ *
+ * DEVIATION (clust indexing): the C loop is `c=1..n_cluster` over the 1-based
+ * `GD_clust(g)[c]`. This port's `g.info.clust` is 0-indexed (populated at
+ * `clust[nc-1]` in rank.ts), so we read `clust[c-1]` for the same cluster.
+ *
+ * @see lib/dotgen/mincross.c:976
+ */
+export declare function realFillRanks(g: Graph, ranks: boolean[], sg: Graph | null): Graph | null;
+/** @see lib/dotgen/mincross.c:fillRanks (1013) */
+export declare function fillRanks(g: Graph): void;
+/** Check that rank r is within the graph's rank range. */
+export declare function rankInRange(g: Graph, r: number): boolean;
+/** Check that node's order doesn't exceed root rank allocation. */
+export declare function orderWithinAlloc(ctx: MincrossContext, r: number, order: number): boolean;
+/** Place node n into its rank slot, honouring vStart for multi-component graphs. */
+export declare function placeInRankSlot(g: Graph, n: Node, r: number): number;
+export declare function installInRank(ctx: MincrossContext, g: Graph, n: Node): number;
+export declare function enqueueNeighbors(q: Node[], n0: Node, pass: number): void;
+export { installCluster };
+export declare function buildRanksFlip(ctx: MincrossContext, g: Graph, mn: number, mx: number): void;
+export declare function buildRanksBfs(ctx: MincrossContext, g: Graph, pass: number, startNode: Node): number;
+export declare function buildRanksFindStart(g: Graph): Node | undefined;
+export declare function buildRanksSources(ctx: MincrossContext, g: Graph, pass: number, ns: Node | undefined): number;
+export declare function buildRanks(ctx: MincrossContext, g: Graph, pass: number): number;
+export declare function doOrderingAddFlatEdges(g: Graph, sortlist: Edge[], outflag: boolean): void;
+export declare function doOrderingNode(ctx: MincrossContext, g: Graph, n: Node, outflag: boolean): void;
+export declare function doOrderingForNodes(ctx: MincrossContext, g: Graph): void;
+export declare function doOrdering(ctx: MincrossContext, g: Graph, outflag: boolean): void;
+export declare function orderedEdges(ctx: MincrossContext, g: Graph): void;
+export { class2 } from './classify.js';
+export { expandCluster, markLowclusters };
+//# sourceMappingURL=mincross-build.d.ts.map

package/dist/layout/dot/mincross-build.d.ts.map

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

package/dist/layout/dot/mincross-cross.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Crossing computation for the mincross algorithm: left2right constraint
+ * checks, in/out crossing counts, exchange, transpose, local_cross, rcross,
+ * and ncross.
+ *
+ * @see lib/dotgen/mincross.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { EdgeList } from '../../model/nodeInfo.js';
+import type { RankEntry } from '../../model/rankEntry.js';
+import { MincrossContext } from './mincross-utils.js';
+export declare function setReMincross(b: boolean): void;
+/** @see lib/dotgen/mincross.c:VAL */
+export declare function val(node: Node, portOrder: number): number;
+/** Edge xpenalty with default 1. @see lib/dotgen/mincross.c */
+export declare function xpen(e: Edge): number;
+/** Signed crossing contribution. @see lib/dotgen/mincross.c:in_cross/out_cross */
+export declare function crossContrib(aVal: number, aPen: number, bVal: number, bPen: number): number;
+/**
+ * Cluster ordering constraint, the guard portion of C's left2right.
+ * Non-remincross: only pairs whose nodes are BOTH in (different) clusters are
+ * forced; a cluster skeleton vnode on either side releases the pair. Remincross:
+ * any cross-cluster pair is forced. Returns 1 = forced (block swap), 0 = defer
+ * to the flat-adjacency matrix. @see lib/dotgen/mincross.c:left2right
+ */
+export declare function left2rightCluster(v: Node, w: Node): number;
+/** @see lib/dotgen/mincross.c:left2right */
+export declare function left2right(g: Graph, v: Node, w: Node): number;
+/**
+ * Crossing counts for the pair (v, w): [c0 = crossings with v before w (the
+ * current order), c1 = crossings with w before v (swapped)]. Mirrors
+ * in_cross(v,w)+out_cross(v,w) and in_cross(w,v)+out_cross(w,v) in one pass.
+ *
+ * `useIn`/`useOut` mirror C transpose_step's gates (mincross.c:646-652):
+ * in-crossings are added only when r > 0, out-crossings only when the next
+ * rank has n > 0. For clusters, allocate_ranks callocs maxrank+2 rank slots
+ * (mincross.c:1163), so the slot past a cluster's maxrank has n == 0 and C
+ * reads that calloc'd n as a gate — it ignores out-crossings at the
+ * cluster's bottom rank. Callers must reproduce both gates; this function no
+ * longer accumulates unconditionally.
+ * @see lib/dotgen/mincross.c:in_cross, out_cross, transpose_step:646-652
+ */
+export declare function transposeCounts(v: Node, w: Node, useIn: boolean, useOut: boolean): [number, number];
+/** @see lib/dotgen/mincross.c:exchange */
+export declare function exchange(ctx: MincrossContext, v: Node, w: Node): void;
+/** C transpose_step swap test: strict improvement, or a reverse tie when there
+ *  are crossings to redistribute. @see lib/dotgen/mincross.c:transpose_step */
+export declare function shouldSwap(c0: number, c1: number, reverse: boolean): boolean;
+/** Returns the total crossing reduction over rank r and marks r and its
+ *  neighbours as candidates. @see lib/dotgen/mincross.c:transpose_step */
+export declare function transposeStep(ctx: MincrossContext, g: Graph, r: number, reverse: boolean): number;
+/**
+ * Repeatedly transpose adjacent nodes within each rank to remove crossings,
+ * re-examining only candidate ranks until no rank improves (delta < 1).
+ * @see lib/dotgen/mincross.c:transpose
+ */
+export declare function transpose(ctx: MincrossContext, g: Graph, reverse: boolean): void;
+/** Crossing contribution for one out/in edge pair. @see lib/dotgen/mincross.c:local_cross */
+export declare function localCrossEdgePair(e: Edge, f: Edge, isOut: boolean): number;
+/** Port-level crossings for one node's edge list. @see lib/dotgen/mincross.c:local_cross */
+export declare function localCrossEdges(edges: EdgeList, dir: number): number;
+/** Count crossings for one node's out-edges vs Count array. `vs` is the head
+ *  rank's window offset. ND_order is stored ABSOLUTE (vStart + index) in this
+ *  port, but C indexes Count by the window-RELATIVE order, and Count is sized to
+ *  the component's rank count. Subtract vs so a component c>0 indexes within the
+ *  Count array; without it, Count[inv] is undefined → NaN → ncross breaks.
+ *  @see lib/dotgen/mincross.c:rcross */
+export declare function rcrossCount(out: EdgeList, Count: number[], max: number, vs: number): number;
+/** Register one node's out-edges in Count; return updated max. `vs`: head rank
+ *  window offset (see rcrossCount). @see lib/dotgen/mincross.c:rcross */
+export declare function rcrossRegister(out: EdgeList, Count: number[], max: number, vs: number): number;
+/** Port crossings for nodes with ports in a single rank. @see lib/dotgen/mincross.c:rcross */
+export declare function rcrossLocal(rk: RankEntry, dir: number): number;
+/** @see lib/dotgen/mincross.c:rcross */
+export declare function rcross(ctx: MincrossContext, g: Graph, r: number): number;
+/** @see lib/dotgen/mincross.c:ncross */
+export declare function ncross(ctx: MincrossContext): number;
+//# sourceMappingURL=mincross-cross.d.ts.map

package/dist/layout/dot/mincross-cross.d.ts.map

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

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

@@ -0,0 +1,27 @@
+/**
+ * Flat-edge handling for the mincross algorithm: flat-edge cycle breaking
+ * (flat_rev / flat_search / flat_breakcycles) and flat reorder
+ * (constraining-edge counting, postorder, flat_reorder).
+ * @see lib/dotgen/mincross.c flat-edge handling
+ */
+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 { MincrossContext } from './mincross-utils.js';
+export declare function flatRevFindRev(head: Node, tail: Node): Edge | undefined;
+export declare function flatRev(g: Graph, e: Edge): void;
+export declare function flatSearchOstack(g: Graph, v: Node, e: Edge, M: RankEntry['flat']): boolean;
+export declare function flatSearchNormal(g: Graph, v: Node, e: Edge, M: RankEntry['flat'], hascl: boolean): void;
+export declare function flatSearchEdge(g: Graph, v: Node, e: Edge, M: RankEntry['flat'], hascl: boolean): boolean;
+export declare function flatSearch(g: Graph, v: Node, M: RankEntry['flat'], hascl: boolean): void;
+export declare function flatBreakcyclesRank(g: Graph, rk: RankEntry, hascl: boolean): void;
+export declare function flatBreakcycles(_ctx: MincrossContext, g: Graph): void;
+export declare function constrainingFlatEdge(g: Graph, e: Edge): boolean;
+export declare function countConstraining(g: Graph, edges: import('../../model/nodeInfo.js').EdgeList): number;
+export declare function postorder(g: Graph, v: Node, list: Node[], r: number): void;
+export declare function flatReorderBuildTemprank(g: Graph, rk: RankEntry, temprank: Node[], flip: boolean): void;
+export declare function flatReorderFixEdges(g: Graph, rk: RankEntry, flip: boolean): void;
+export declare function flatReorderRank(g: Graph, rk: RankEntry, rootRank: RankEntry[], r: number, flip: boolean): void;
+export declare function flatReorder(_ctx: MincrossContext, g: Graph): void;
+//# sourceMappingURL=mincross-flat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mincross-flat.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/mincross-flat.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;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,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAM1D,OAAO,EACL,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAG7B,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAOvE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAa/C;AAGD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,OAAO,CAO1F;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAKvG;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAOxG;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAYxF;AAGD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAoBjF;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CASrE;AAGD,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAK/D;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,yBAAyB,EAAE,QAAQ,GAAG,MAAM,CAMrG;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAW1E;AAGD,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAQvG;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAiBhF;AAED,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAkB9G;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CAUjE"}

package/dist/layout/dot/mincross-order.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Ordering/median pass and mincross main loop for the mincross algorithm.
+ * Build-phase helpers live in mincross-build.ts.
+ *
+ * @see lib/dotgen/mincross.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { RankEntry } from '../../model/rankEntry.js';
+import type { EdgeList } from '../../model/nodeInfo.js';
+import { MincrossContext } from './mincross-utils.js';
+type StepBounds = {
+    first: number;
+    last: number;
+    dir: number;
+};
+type CrossState = {
+    cur: number;
+    best: number;
+};
+type ReorderResult = {
+    rp: number;
+    muststay: boolean;
+};
+export declare function setMincrossTrace(fn: ((line: string) => void) | null): void;
+export declare function flatMvalIn(n: Node, fi: EdgeList): boolean;
+export declare function flatMvalOut(n: Node, fo: EdgeList): boolean;
+/** @see lib/dotgen/mincross.c:flat_mval */
+export declare function flatMval(n: Node): boolean;
+/** Collect val() samples for one node's adjacent edges. @see lib/dotgen/mincross.c:mval */
+export declare function mediansCollectDir(v: Node, d: number, list: number[]): void;
+/**
+ * C operates on an int[] (VAL = MC_SCALE*ND_order + port.order), so the n==2
+ * average and the equal-span case use INTEGER division (truncation toward
+ * zero), not float. Using float here yields x.5 mvals that perturb the reorder
+ * sort and diverge from C on tie-heavy ranks (e.g. 2371's flat mid network).
+ * The unequal-span weighted median stays a true double, matching C.
+ * @see lib/dotgen/mincross.c:median
+ */
+export declare function computeMedian(list: number[]): number;
+/**
+ * Loop 1 body of C `medians` (mincross.c:1627-1667) — computes a fresh mval
+ * for a SINGLE node from its directional fast-edge list. An empty list
+ * (including nodes with no fast edges in this direction at all — case 0 at
+ * mincross.c:1643) resets mval to -1 via computeMedian. This must run for
+ * EVERY node in the rank, unconditionally, before flat_mval (loop 2 in
+ * `medians` below) reads any node's mval.
+ * @see lib/dotgen/mincross.c:1621-1667
+ */
+export declare function mediansProcessNode(v: Node, d: number): void;
+/**
+ * @see lib/dotgen/mincross.c:1621
+ *
+ * Mirrors C's exact two-loop shape. Loop 1 resets/sets mval for EVERY node
+ * in the rank (mincross.c:1627-1667). Loop 2 runs flat_mval only for nodes
+ * with NO fast edges in either direction (mincross.c:1669-1673), strictly
+ * after loop 1 has completed for the whole rank — so flat_mval always
+ * observes a freshly-reset mval, never a stale value left over from the
+ * opposite pass direction. A fused single-loop version that early-returns
+ * into flat_mval for edge-less nodes skips the loop-1 reset for exactly
+ * those nodes, leaking stale cross-pass mval into the reorder comparator.
+ * @see plans/residual-cleanup/analysis/1453-medians-reset.md
+ */
+export declare function medians(_ctx: MincrossContext, g: Graph, r: number, d: number): boolean;
+/** @see lib/dotgen/mincross.c:save_best */
+export declare function saveBest(g: Graph): void;
+export declare function restoreRank(rk: RankEntry, rootRk: RankEntry): void;
+/** @see lib/dotgen/mincross.c:restore_best */
+export declare function restoreBest(ctx: MincrossContext, g: Graph): void;
+export declare function reorderFindLp(vlist: Node[], lp: number, ep: number): number;
+export declare function reorderFindRp(g: Graph, vlist: Node[], lp: number, ep: number): ReorderResult;
+export declare function reorderInner(ctx: MincrossContext, g: Graph, vlist: Node[], win: {
+    start: number;
+    ep: number;
+}, reverse: boolean): boolean;
+/** @see lib/dotgen/mincross.c:reorder */
+export declare function reorder(ctx: MincrossContext, g: Graph, r: number, reverse: boolean, hasfixed: boolean): void;
+/** @see lib/dotgen/mincross.c:mincross_step (bounds computation) */
+export declare function mincrossStepBounds(ctx: MincrossContext, g: Graph, pass: number): StepBounds;
+/** @see lib/dotgen/mincross.c:mincross_step */
+export declare function mincrossStep(ctx: MincrossContext, g: Graph, pass: number): void;
+/** @see lib/dotgen/mincross.c:mincross (iteration loop) */
+export declare function mincrossIter(ctx: MincrossContext, g: Graph, maxthispass: number, state: CrossState, pass: number): void;
+/** @see lib/dotgen/mincross.c:mincross (pass setup) */
+export declare function mincrossPassSetup(ctx: MincrossContext, g: Graph, pass: number, state: CrossState): number;
+/** @see lib/dotgen/mincross.c:mincross */
+export declare function mincrossMain(ctx: MincrossContext, g: Graph, startpass: number): number;
+export {};
+//# sourceMappingURL=mincross-order.d.ts.map

package/dist/layout/dot/mincross-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mincross-order.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/mincross-order.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;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;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAiC,MAAM,qBAAqB,CAAC;AAIrF,KAAK,UAAU,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAC/D,KAAK,UAAU,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAChD,KAAK,aAAa,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AASvD,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAE1E;AAMD,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,GAAG,OAAO,CAWzD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,QAAQ,GAAG,OAAO,CAW1D;AAED,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,OAAO,CAMzC;AAMD,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAa1E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAYpD;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAI3D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAwBtF;AAMD,2CAA2C;AAC3C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAoBvC;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAWlE;AAED,8CAA8C;AAC9C,wBAAgB,WAAW,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,GAAG,IAAI,CAOhE;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAW3E;AAUD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,aAAa,CAc5F;AAED,wBAAgB,YAAY,CAC1B,GAAG,EAAE,eAAe,EACpB,CAAC,EAAE,KAAK,EACR,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,EAClC,OAAO,EAAE,OAAO,GACf,OAAO,CAuBT;AAUD,yCAAyC;AACzC,wBAAgB,OAAO,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAiB5G;AAMD,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CAW3F;AAED,+CAA+C;AAC/C,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAQ/E;AAMD,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAgBvH;AAED,uDAAuD;AACvD,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAczG;AAED,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAatF"}

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

@@ -0,0 +1,60 @@
+/**
+ * Shared utilities for the mincross family: context type, AdjMatrix helpers,
+ * graph helpers, and node cluster helpers.
+ * Imported by mincross.ts, mincross-build.ts, mincross-cross.ts, and
+ * mincross-order.ts to avoid circular dependencies.
+ *
+ * @see lib/dotgen/mincross.c
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { AdjMatrix, RankEntry } from '../../model/rankEntry.js';
+/** @see lib/dotgen/mincross.c:Convergence */
+export declare const CONVERGENCE = 0.995;
+/**
+ * Replaces C module-level statics (Root, GlobalMinRank/MaxRank, TE_list,
+ * TI_list, ReMincross, MinQuit, MaxIter) for reentrancy.
+ * @see lib/dotgen/mincross.c (module statics)
+ */
+export interface MincrossContext {
+    root: Graph;
+    globalMinRank: number;
+    globalMaxRank: number;
+    teList: Edge[];
+    tiList: number[];
+    reMincross: boolean;
+    minQuit: number;
+    maxIter: number;
+}
+/** @see lib/dotgen/mincross.c:matrix_get */
+export declare function matrixGet(m: AdjMatrix, row: number, col: number): boolean;
+/** @see lib/dotgen/mincross.c:matrix_set */
+export declare function matrixSet(m: AdjMatrix, row: number, col: number): void;
+/** Copy all set bits into new buffer with updated column count. */
+export declare function matrixCopyBits(m: AdjMatrix, data: Uint8Array, ncols: number): void;
+/** @see lib/dotgen/mincross.c:new_matrix */
+export declare function newMatrix(rows: number, cols: number): AdjMatrix;
+/** @see lib/dotgen/dot.h:dot_root */
+export declare function dotRoot(g: Graph): Graph;
+/** @see lib/cgraph/cgraph.h:agcontains (node) */
+export declare function agContainsNode(g: Graph, n: Node): boolean;
+/** @see lib/cgraph/cgraph.h:agcontains (edge) */
+export declare function agContainsEdge(g: Graph, e: Edge): boolean;
+/** Get rank.v[i] respecting vStart pointer-arithmetic offset. */
+export declare function rankGet(rank: RankEntry, i: number): Node;
+/** Set rank.v[i] respecting vStart pointer-arithmetic offset. */
+export declare function rankSet(rank: RankEntry, i: number, n: Node): void;
+/** @see lib/dotgen/mincross.c:is_a_normal_node_of */
+export declare function isNormalNodeOf(g: Graph, v: Node): boolean;
+/** @see lib/dotgen/mincross.c:is_a_vnode_of_an_edge_of */
+export declare function isVnodeOfEdgeOf(g: Graph, v: Node): boolean;
+/** @see lib/dotgen/mincross.c:inside_cluster */
+export declare function insideCluster(g: Graph, v: Node): boolean;
+/** @see lib/dotgen/mincross.c:neighbor
+ * Only the Root global is consulted, so callers outside the mincross pass
+ * (flat_edges' vlist reset runs in dot_position) may pass a bare `{root}`. */
+export declare function neighborNode(ctx: Pick<MincrossContext, 'root'>, v: Node, dir: number): Node | undefined;
+/** @see lib/dotgen/mincross.c:furthestnode */
+export declare function furthestNode(ctx: Pick<MincrossContext, 'root'>, g: Graph, v: Node, dir: number): Node;
+//# sourceMappingURL=mincross-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mincross-utils.d.ts","sourceRoot":"","sources":["../../../src/layout/dot/mincross-utils.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;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,SAAS,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAOrE,6CAA6C;AAC7C,eAAO,MAAM,WAAW,QAAQ,CAAC;AAMjC;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,KAAK,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,IAAI,EAAE,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAMD,4CAA4C;AAC5C,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAIzE;AAED,4CAA4C;AAC5C,wBAAgB,SAAS,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAItE;AAED,mEAAmE;AACnE,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAQlF;AAcD,4CAA4C;AAC5C,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAI/D;AAMD,qCAAqC;AACrC,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,KAAK,CAEvC;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEzD;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEzD;AAMD,iEAAiE;AACjE,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAExD;AAED,iEAAiE;AACjE,wBAAgB,OAAO,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAEjE;AAMD,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEzD;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAQ1D;AAED,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAExD;AAED;;8EAE8E;AAC9E,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAMvG;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAOrG"}