@knowvah/dot-engine 0.1.0

package/dist/model/node.d.ts

@@ -0,0 +1,101 @@
+/**
+ * TypeScript port of Agnode_t from lib/cgraph/cgraph.h.
+ *
+ * @see lib/cgraph/cgraph.h:Agnode_s
+ */
+import type { Edge } from './edge.js';
+import type { Graph } from './graph.js';
+import { type NodeInfo } from './nodeInfo.js';
+/**
+ * Represents an Agnode_t — a graph node.
+ *
+ * In the C implementation, Agnode_t embeds Agobj_t (tag + data), holds a
+ * pointer to its root graph, and contains an embedded Agsubnode_t for the
+ * main graph. Per-graph membership is tracked via Agsubnode_t records in
+ * libcdt dicts. Here node identity is object identity (pointer comparison
+ * in C maps to reference equality in TypeScript).
+ *
+ * The `info` field replaces the agbindrec / ND_* mechanism (AD-1).
+ *
+ * @see lib/cgraph/cgraph.h:Agnode_s
+ * @see lib/cgraph/cgraph.h:Agsubnode_s
+ */
+export declare class Node {
+    /**
+     * Unique integer ID per root graph; maps to AGID in the C implementation.
+     * @see lib/cgraph/cgraph.h:AGID
+     */
+    readonly id: number;
+    /** Node name; agnameof equivalent. @see lib/cgraph/cgraph.h:agnameof */
+    readonly name: string;
+    /**
+     * String attributes (agget/agset equivalents).
+     * @see lib/cgraph/cgraph.h:Agattr_s
+     */
+    attrs: Map<string, string>;
+    /**
+     * Layout-engine info; replaces ND_* macros via agbindrec (AD-1).
+     * @see lib/cgraph/cgraph.h:agbindrec
+     */
+    info: NodeInfo;
+    /**
+     * Root graph that owns this node.
+     * @see lib/cgraph/cgraph.h:Agnode_s
+     */
+    readonly root: Graph;
+    /**
+     * Frozen snapshot of the node-attribute defaults (`node [...]`) in effect —
+     * from the declaring subgraph up through its ancestors — at the moment this
+     * node was first created. Captured at creation (not read live at render) so
+     * that a `node [...]` declared *after* this node in the same or an ancestor
+     * scope does not retroactively apply, matching DOT semantics. Present on
+     * parser-built nodes (even when empty); undefined on programmatically created
+     * nodes, which fall back to live graph defaults in `nodeAttr`.
+     */
+    nodeDefaultsSnapshot?: Map<string, string>;
+    /** @see lib/cgraph/node.c:agnode */
+    constructor(id: number, name: string, root: Graph);
+    /**
+     * Returns out-edges of this node in graph g (where this node is the tail).
+     *
+     * ORDER: cgraph's per-node out-edge dict sorts by the SEQ of the edge's
+     * out-half node — the HEAD — then by edge seq (edge.c:agedgeseqcmpf,
+     * Ag_mainedge_seq_disc). Iteration is therefore by (head creation order,
+     * edge creation order), NOT by plain edge insertion order. This ordering
+     * is load-bearing for emission order and for force-accumulation order in
+     * the iterative engines.
+     *
+     * INVARIANT: In the C cgraph library, the adjacency list for a node begins
+     * with the node's own self-loop (index 0), and neighbor traversal MUST start
+     * at index 1. This convention originates from lib/cgraph/edge.c and
+     * agfstedge/agnxtedge. In this TypeScript implementation, self-loops are
+     * included in outEdges() but are excluded from inEdges() — matching the
+     * agnxtedge behavior that skips self-loops as in-edges. Callers iterating
+     * over neighbors must account for self-loop edges appearing in outEdges().
+     *
+     * @see lib/cgraph/edge.c:agfstout
+     * @see lib/cgraph/edge.c:agnxtout
+     * @see lib/cgraph/edge.c:agedgeseqcmpf
+     */
+    outEdges(g: Graph): Edge[];
+    /**
+     * Returns in-edges of this node in graph g (where this node is the head).
+     * Self-loops are excluded per C agnxtedge semantics. Ordered by the SEQ
+     * of the in-half node — the TAIL — then edge seq (agedgeseqcmpf).
+     *
+     * @see lib/cgraph/edge.c:agfstin
+     * @see lib/cgraph/edge.c:agnxtin
+     * @see lib/cgraph/edge.c:agnxtedge (skips self-loops as in-edges)
+     * @see lib/cgraph/edge.c:agedgeseqcmpf
+     */
+    inEdges(g: Graph): Edge[];
+}
+/**
+ * Build a tail→out-edges index for graph `g`. Each list is identical to
+ * `node.outEdges(g)` (tail === node, self-loops included, sorted by head.id then
+ * seq), but the whole index is O(E log E) instead of O(N·E log E) from calling
+ * outEdges once per node. Use at sites that loop every node's out-edges and do
+ * not mutate `g.edges` during the loop. @see Node.outEdges
+ */
+export declare function buildOutEdgeIndex(g: Graph): Map<Node, Edge[]>;
+//# sourceMappingURL=node.d.ts.map

package/dist/model/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/model/node.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,EAAE,KAAK,QAAQ,EAAgB,MAAM,eAAe,CAAC;AAE5D;;;;;;;;;;;;;GAaG;AACH,qBAAa,IAAI;IACf;;;OAGG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;OAGG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3B;;;OAGG;IACH,IAAI,EAAE,QAAQ,CAAC;IAEf;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAErB;;;;;;;;OAQG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE3C,oCAAoC;gBACxB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK;IAQjD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;IAM1B;;;;;;;;;OASG;IACH,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE;CAK1B;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAW7D"}

package/dist/model/nodeInfo.d.ts

@@ -0,0 +1,278 @@
+/**
+ * TypeScript port of Agnodeinfo_t from lib/common/types.h.
+ *
+ * All ND_* macros in the C source expand into this struct via AGDATA().
+ * In TypeScript, ND_* accesses become direct property reads/writes on NodeInfo.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/common/types.h:ND_* macros
+ */
+import type { Point, Box } from './geom.js';
+import type { Edge } from './edge.js';
+import type { Graph } from './graph.js';
+import type { Node } from './node.js';
+import type { NodeAlgData } from './algData.js';
+export type { DotAlgData, NeatoAlgData, FdpAlgData, FdpDndata, CircoNData, CircoCData, TwopiAlgData, OsageAlgData, PatchworkAlgData, NodeAlgData, } from './algData.js';
+export { THETA_UNSET } from './algData.js';
+/**
+ * Dynamic edge list, ported from the C `elist` struct.
+ *
+ * @see lib/common/types.h: typedef struct elist { edge_t **list; size_t size; }
+ */
+export interface EdgeList {
+    list: Edge[];
+    size: number;
+}
+/**
+ * Node-level layout info record, ported from Agnodeinfo_t in lib/common/types.h.
+ *
+ * This interface replaces all ND_* macro accesses in the C source. Required
+ * (always-present) fields mirror the non-pointer, non-conditional fields of
+ * Agnodeinfo_t. Optional fields correspond to pointer fields and to fields
+ * gated by #ifndef DOT_ONLY / #ifndef NEATO_ONLY.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/common/types.h:ND_* macros
+ */
+export interface NodeInfo {
+    /** Final layout coordinate (node center). @see lib/common/types.h:ND_coord */
+    coord: Point;
+    /** Node width in inches. @see lib/common/types.h:ND_width */
+    width: number;
+    /** Node height in inches. @see lib/common/types.h:ND_height */
+    height: number;
+    /** Bounding box. @see lib/common/types.h:ND_bb */
+    bb: Box;
+    /** Total height in points. @see lib/common/types.h:ND_ht */
+    ht: number;
+    /** Left half-width in points. @see lib/common/types.h:ND_lw */
+    lw: number;
+    /** Right half-width in points. @see lib/common/types.h:ND_rw */
+    rw: number;
+    /**
+     * Width in points with penwidth taken into account.
+     * @see lib/common/types.h:ND_outline_width
+     */
+    outline_width: number;
+    /**
+     * Height in points with penwidth taken into account.
+     * @see lib/common/types.h:ND_outline_height
+     */
+    outline_height: number;
+    /**
+     * Pre-periphery-growth node width in inches: the box the innermost
+     * vertex ring is scaled to before peripheries step outward. Only set
+     * by the measurer sizing path; consumed by multi-periphery vertex
+     * generation. (C keeps the equivalent implicitly — poly_init builds
+     * vertices and bb in one pass.)
+     * @see lib/common/shapes.c:poly_init
+     */
+    base_width?: number;
+    /** Pre-periphery-growth node height in inches. @see base_width */
+    base_height?: number;
+    /**
+     * Layout state (char in C). @see lib/common/types.h:ND_state
+     */
+    state: number;
+    /**
+     * Node state for GUI ops (unsigned char in C).
+     * Bitfield values: GUI_STATE_ACTIVE, GUI_STATE_SELECTED,
+     * GUI_STATE_VISITED, GUI_STATE_DELETED.
+     * @see lib/common/types.h:ND_gui_state
+     */
+    gui_state: number;
+    /** True if node represents a cluster. @see lib/common/types.h:ND_clustnode */
+    clustnode: boolean;
+    /**
+     * Main node label (textlabel_t* in C).
+     * Typed as unknown until textlabel_t is ported in Batch 5b.
+     * @see lib/common/types.h:ND_label
+     */
+    label?: unknown;
+    /**
+     * External node label (textlabel_t* in C).
+     * Typed as unknown until textlabel_t is ported in Batch 5b.
+     * @see lib/common/types.h:ND_xlabel
+     */
+    xlabel?: unknown;
+    /**
+     * Node shape descriptor (shape_desc* in C).
+     * Typed as unknown until shape_desc is ported.
+     * @see lib/common/types.h:ND_shape
+     */
+    shape?: unknown;
+    /**
+     * Shape-specific data (polygon_t*, field_t*, or engine struct in C).
+     * Typed as unknown until the concrete shape types are ported.
+     * @see lib/common/types.h:ND_shape_info
+     */
+    shape_info?: unknown;
+    /**
+     * During the dot rank-assignment phase this field holds the assigned rank
+     * (integer row in the layered graph).
+     *
+     * DUAL-USE WARNING: During the dot position phase (x-coordinate assignment),
+     * `rank` is REPURPOSED as the x-coordinate by network simplex. Do not read
+     * this field as a rank value while the position phase is active. The field
+     * is restored to its rank value by `set_xcoords` at the end of the position
+     * phase. See lib/dotgen/position.c and AD-8.
+     *
+     * @see lib/common/types.h:ND_rank
+     */
+    rank?: number;
+    /**
+     * Initial order for ordered edges; also used in crossing-minimization.
+     * @see lib/common/types.h:ND_order
+     */
+    order?: number;
+    /**
+     * AD-8: True while the position phase is active and `rank` holds an
+     * x-coordinate instead of a rank index. Set before rank(g,2,…) is called;
+     * cleared by setXcoords after ND_coord.x is populated.
+     * @see lib/dotgen/position.c:set_xcoords
+     */
+    rankIsXCoord?: boolean;
+    /** @see lib/common/types.h:ND_mval */
+    mval?: number;
+    /**
+     * Fast-graph / spanning-tree node type (char in C).
+     * @see lib/common/types.h:ND_node_type
+     */
+    node_type?: number;
+    /**
+     * Rank type classification (char in C).
+     * @see lib/common/types.h:ND_ranktype
+     */
+    ranktype?: number;
+    /**
+     * Weight class (char in C).
+     * @see lib/common/types.h:ND_weight_class
+     */
+    weight_class?: number;
+    /**
+     * Visited / traversal mark (size_t in C).
+     * @see lib/common/types.h:ND_mark
+     */
+    mark?: number;
+    /**
+     * On-stack flag for DFS (char in C).
+     * @see lib/common/types.h:ND_onstack
+     */
+    onstack?: number;
+    /**
+     * True if edge has port info. @see lib/common/types.h:ND_has_port
+     */
+    has_port?: boolean;
+    /**
+     * Showboxes flag (unsigned char in C).
+     * @see lib/common/types.h:ND_showboxes
+     */
+    showboxes?: number;
+    /** In-edges. @see lib/common/types.h:ND_in */
+    in?: EdgeList;
+    /** Out-edges. @see lib/common/types.h:ND_out */
+    out?: EdgeList;
+    /** Flat in-edges (same-rank). @see lib/common/types.h:ND_flat_in */
+    flat_in?: EdgeList;
+    /** Flat out-edges (same-rank). @see lib/common/types.h:ND_flat_out */
+    flat_out?: EdgeList;
+    /** Other (non-tree, non-flat) edges. @see lib/common/types.h:ND_other */
+    other?: EdgeList;
+    /** Saved in-edges (for virtual node removal). @see lib/common/types.h:ND_save_in */
+    save_in?: EdgeList;
+    /** Saved out-edges (for virtual node removal). @see lib/common/types.h:ND_save_out */
+    save_out?: EdgeList;
+    /** Network-simplex tree in-edges. @see lib/common/types.h:ND_tree_in */
+    tree_in?: EdgeList;
+    /** Network-simplex tree out-edges. @see lib/common/types.h:ND_tree_out */
+    tree_out?: EdgeList;
+    /** Next node in doubly-linked fast-graph list. @see lib/common/types.h:ND_next */
+    next?: Node;
+    /** Previous node in doubly-linked fast-graph list. @see lib/common/types.h:ND_prev */
+    prev?: Node;
+    /**
+     * Network-simplex spanning-tree parent edge.
+     * @see lib/common/types.h:ND_par
+     */
+    par?: Edge;
+    /** Low limit for network simplex. @see lib/common/types.h:ND_low */
+    low?: number;
+    /** Limit for network simplex subtree. @see lib/common/types.h:ND_lim */
+    lim?: number;
+    /** Priority for network simplex edge selection. @see lib/common/types.h:ND_priority */
+    priority?: number;
+    /** Union-find tree size. @see lib/common/types.h:ND_UF_size */
+    UF_size?: number;
+    /** Union-find parent node. @see lib/common/types.h:ND_UF_parent */
+    UF_parent?: Node;
+    /** Representative node for a collapsed set. @see lib/common/types.h:ND_rep */
+    rep?: Node;
+    /** Set leader for min/max rank. @see lib/common/types.h:ND_set */
+    set?: Node;
+    /** Cluster subgraph that this node belongs to. @see lib/common/types.h:ND_clust */
+    clust?: Graph;
+    /**
+     * Flat-edge label constraint edge stored in ND_alg during dot position phase.
+     * Set by flat.c when a virtual node hosts a flat-edge label; read by
+     * make_LR_constraints and dotsplines.c.
+     * @see lib/dotgen/flat.c:ND_alg (flat edge label usage)
+     */
+    posAlg?: Edge;
+    /**
+     * True if the node's position is pinned (pos attribute with !).
+     * @see lib/common/types.h:ND_pinned
+     */
+    pinned?: boolean;
+    /**
+     * True if the node has a user-supplied `pos=` (C's ND_pinned >= P_SET, i.e.
+     * hasPos). Distinct from {@link pinned} (P_PIN, isFixed): a plain `pos=`
+     * seeds the initial layout without fixing the node. neato uses it to start
+     * majorization from the input positions (user_pos + hasPos).
+     * @see lib/neatogen/neatoinit.c:user_pos; lib/common/macros.h:hasPos
+     */
+    posSet?: boolean;
+    /**
+     * Internal integer node ID used by neato/fdp.
+     * @see lib/common/types.h:ND_id
+     */
+    id?: number;
+    /**
+     * Index into the priority queue heap (neato/fdp).
+     * @see lib/common/types.h:ND_heapindex
+     */
+    heapindex?: number;
+    /**
+     * BFS hop count from the starting node (neato/fdp).
+     * @see lib/common/types.h:ND_hops
+     */
+    hops?: number;
+    /**
+     * N-dimensional position vector (length = ndim).
+     * @see lib/common/types.h:ND_pos
+     */
+    pos?: number[];
+    /**
+     * Distance value used by neato stress majorization.
+     * @see lib/common/types.h:ND_dist
+     */
+    dist?: number;
+    /**
+     * Per-engine algorithm data. Each layout engine stores a different struct
+     * in ND_alg; the `kind` discriminant identifies which engine's data is
+     * active without unsafe casting (AD-7).
+     *
+     * @see lib/common/types.h:ND_alg
+     */
+    alg?: NodeAlgData;
+}
+/**
+ * Constructs a zero-valued NodeInfo with all required fields set to their
+ * zero/false initial state and all optional fields absent (undefined).
+ *
+ * Mirrors the effect of calloc-initializing an Agnodeinfo_t in C.
+ *
+ * @see lib/common/types.h:Agnodeinfo_t
+ * @see lib/cgraph/node.c:agnode (initial record allocation via agbindrec)
+ */
+export declare function makeNodeInfo(): NodeInfo;
+//# sourceMappingURL=nodeInfo.d.ts.map

package/dist/model/nodeInfo.d.ts.map

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

package/dist/model/rankEntry.d.ts

@@ -0,0 +1,80 @@
+/**
+ * RankEntry and RankTable — one rank in a dot-layout ranked graph.
+ * Ported from lib/common/types.h:rank_t.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+import type { Node } from './node.js';
+/**
+ * Bit-packed flat-edge adjacency matrix for one rank.
+ * Bit (r,c) = data[(r*ncols+c)>>3] >> ((r*ncols+c)&7) & 1.
+ * Dynamically expands on matrixSet.
+ * @see lib/dotgen/mincross.c:adjmatrix_t
+ */
+export interface AdjMatrix {
+    nrows: number;
+    ncols: number;
+    data: Uint8Array;
+}
+/**
+ * One rank in a dot-layout ranked graph.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+export interface RankEntry {
+    /** Number of nodes in this rank. @see lib/common/types.h:rank_t.n */
+    n: number;
+    /** Ordered list of nodes in rank. @see lib/common/types.h:rank_t.v */
+    v: Node[];
+    /**
+     * Globally allocated number of nodes.
+     * @see lib/common/types.h:rank_t.an
+     */
+    an: number;
+    /** Allocated list of nodes in rank. @see lib/common/types.h:rank_t.av */
+    av: Node[];
+    /** Height below centerline. @see lib/common/types.h:rank_t.ht1 */
+    ht1: number;
+    /** Height above centerline. @see lib/common/types.h:rank_t.ht2 */
+    ht2: number;
+    /**
+     * Height below centerline (primitive nodes only).
+     * @see lib/common/types.h:rank_t.pht1
+     */
+    pht1: number;
+    /**
+     * Height above centerline (primitive nodes only).
+     * @see lib/common/types.h:rank_t.pht2
+     */
+    pht2: number;
+    /** For transpose(). @see lib/common/types.h:rank_t.candidate */
+    candidate: boolean;
+    /** Whether rank is valid. @see lib/common/types.h:rank_t.valid */
+    valid: boolean;
+    /**
+     * Cached crossing count.
+     * C type is int64_t; JS number is safe up to 2^53.
+     * @see lib/common/types.h:rank_t.cache_nc
+     */
+    cache_nc: number;
+    /**
+     * Flat-edge adjacency matrix for cycle-breaking. Allocated per-rank by
+     * flatBreakcycles when any flat edges exist; freed in cleanup2.
+     * @see lib/dotgen/mincross.c:GD_rank(g)[r].flat
+     */
+    flat?: AdjMatrix;
+    /**
+     * Offset into av[] for the current connected component's slice.
+     * Simulates C pointer arithmetic: C's `rank[r].v = rank[r].av + offset`
+     * becomes TypeScript's `vStart`.
+     * @see lib/dotgen/mincross.c:init_mccomp
+     */
+    vStart?: number;
+}
+/**
+ * Array of rank entries for a ranked (dot) graph layout.
+ *
+ * @see lib/common/types.h:rank_t
+ */
+export type RankTable = RankEntry[];
+//# sourceMappingURL=rankEntry.d.ts.map

package/dist/model/rankEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rankEntry.d.ts","sourceRoot":"","sources":["../../src/model/rankEntry.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAMtC;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;CAClB;AAMD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,CAAC,EAAE,MAAM,CAAC;IACV,sEAAsE;IACtE,CAAC,EAAE,IAAI,EAAE,CAAC;IACV;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,EAAE,EAAE,IAAI,EAAE,CAAC;IACX,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,SAAS,EAAE,OAAO,CAAC;IACnB,kEAAkE;IAClE,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;;;OAIG;IACH,IAAI,CAAC,EAAE,SAAS,CAAC;IAEjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC"}

package/dist/ortho/chan-dict.d.ts

@@ -0,0 +1,82 @@
+/**
+ * C-exact cdt Dtoset for the ortho channel dictionaries.
+ *
+ * The ortho maze keeps its channels in two-level cdt Dtoset splay trees and
+ * walks them with `dtflatten` + `dtlink` (following raw `->right` pointers).
+ * Crucially, `add_p_edges` calls `chanSearch` (a `dtmatch`) WHILE walking the
+ * flattened dicts: the first search UNFLATTENs the dict (the sorted right-
+ * spine chain simply becomes the tree again) and every search top-down-splays
+ * the tree, rewriting the very `->right` pointers the walker is following.
+ * The walk therefore silently skips every channel that a splay rotation moves
+ * into a left subtree — under 1447_1/osage C visits only 157 of 294 channels
+ * in the parallel pass. This behavior is deterministic and LOAD-BEARING: the
+ * final precedence graphs (and thus track assignments) depend on exactly
+ * which channels the corrupted walk reaches.
+ *
+ * The repo's generic DtSplay deliberately deviates from dttree.c in the
+ * not-found reassembly and insert attachment (documented in splay-core.ts),
+ * which changes tree SHAPE — harmless for its users, fatal here where shape
+ * drives the walk. Hence this separate byte-faithful implementation.
+ *
+ * Ports exactly:
+ *   - dttree.c do_search loop + found (has_root) and not-found (no_root)
+ *     reassembly, DT_MATCH and DT_INSERT flavours (DT_OSET only).
+ *   - dtflatten.c right-linearisation (RROTATE loop) + DT_FLATTEN flag.
+ *   - dthdr.h UNFLATTEN: any tree op clears the flag; for DT_OSET the
+ *     flattened chain IS a valid (degenerate) tree, so no restructuring.
+ *
+ * @see lib/cdt/dttree.c:dttree
+ * @see lib/cdt/dtflatten.c:dtflatten
+ * @see lib/cdt/dtrestore.c:dtrestore
+ * @see lib/ortho/ortho.c:chanSearch, assignTracks (dtflatten walks)
+ */
+/** Dtlink_t analogue. Walkers follow `.right` live, exactly like dtlink(). */
+export interface CdtNode<T> {
+    left: CdtNode<T> | null;
+    right: CdtNode<T> | null;
+    obj: T;
+}
+/**
+ * Ordered set (DT_OSET) with C-exact splay + flatten semantics.
+ * K is the search-key type; the comparator receives (searchKey, nodeKey).
+ */
+export declare class CdtOset<T, K> {
+    private readonly keyOf;
+    private readonly cmp;
+    /** dt->data.here — current root (or flattened-list head). */
+    here: CdtNode<T> | null;
+    /** DT_FLATTEN flag. */
+    private flattened;
+    constructor(keyOf: (obj: T) => K, cmp: (a: K, b: K) => number);
+    /** UNFLATTEN(dt): clear the flag. For DT_OSET dtrestore leaves `here`
+     *  pointing at the chain head — the right-spine chain IS the tree. */
+    private unflatten;
+    /**
+     * The dttree.c do_search loop. Returns the stopped-at node (`root` in C,
+     * null when the key fell off the tree) plus the partition state.
+     * link.right = LEFT partition head, link.left = RIGHT partition head
+     * (names inverted in C — preserved). l/r are the partition tails.
+     * @see lib/cdt/dttree.c:dttree (do_search)
+     */
+    private search;
+    /**
+     * dtmatch: search by key, splaying. Returns the object or null.
+     * Found: has_root reassembly. Not found: no_root reassembly.
+     * @see lib/cdt/dttree.c:dttree (DT_MATCH)
+     */
+    match(key: K): T | null;
+    /**
+     * dtinsert (DT_OSET): if an equal object exists, splay it to root and
+     * return IT (the caller must discard its own copy — C frees it). Otherwise
+     * the new node becomes root with the raw partitions as its subtrees.
+     * @see lib/cdt/dttree.c:dttree (DT_INSERT)
+     */
+    insert(obj: T): T;
+    /**
+     * dtflatten: right-linearise the tree into a sorted chain (returns head).
+     * Early-returns the existing chain when already flattened.
+     * @see lib/cdt/dtflatten.c:dtflatten
+     */
+    flatten(): CdtNode<T> | null;
+}
+//# sourceMappingURL=chan-dict.d.ts.map

package/dist/ortho/chan-dict.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chan-dict.d.ts","sourceRoot":"","sources":["../../src/ortho/chan-dict.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,8EAA8E;AAC9E,MAAM,WAAW,OAAO,CAAC,CAAC;IACxB,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACzB,GAAG,EAAE,CAAC,CAAC;CACR;AAcD;;;GAGG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC;IAOrB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAPtB,6DAA6D;IAC7D,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAQ;IAC/B,uBAAuB;IACvB,OAAO,CAAC,SAAS,CAAS;gBAGP,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,EACpB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAG9C;0EACsE;IACtE,OAAO,CAAC,SAAS;IAIjB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM;IAmEd;;;;OAIG;IACH,KAAK,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,IAAI;IAuBvB;;;;;OAKG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAyBjB;;;;OAIG;IACH,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;CAuB7B"}

package/dist/ortho/fpq.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Max-heap priority queue for Dijkstra shortest path.
+ *
+ * Faithful port of lib/ortho/fPQ.c.
+ * Values stored NEGATED — larger negative = lower priority.
+ * The guard node at index 0 has nVal = 0, so upheap stops at root.
+ *
+ * @see lib/ortho/fPQ.c
+ * @see lib/ortho/fPQ.h
+ */
+import type { SNode } from "./types.js";
+/**
+ * Priority queue state.
+ * @see lib/ortho/fPQ.c:struct pq
+ */
+export interface Pq {
+    pq: (SNode | null)[];
+    cnt: number;
+    guard: SNode;
+    size: number;
+}
+/**
+ * Allocate a priority queue for up to sz nodes.
+ * @see lib/ortho/fPQ.c:PQgen
+ */
+export declare function pqGen(sz: number): Pq;
+/**
+ * Free the priority queue. (No-op in TS.)
+ * @see lib/ortho/fPQ.c:PQfree
+ */
+export declare function pqFree(_pq: Pq): void;
+/**
+ * Reset the priority queue to empty.
+ * @see lib/ortho/fPQ.c:PQinit
+ */
+export declare function pqInit(pq: Pq): void;
+/**
+ * Insert node np into the queue.
+ * Returns 1 on overflow, 0 on success.
+ * @see lib/ortho/fPQ.c:PQ_insert
+ */
+export declare function pqInsert(pq: Pq, np: SNode): number;
+/**
+ * Remove and return the node with the highest nVal (most-negative distance).
+ * Returns null when queue is empty.
+ * @see lib/ortho/fPQ.c:PQremove
+ */
+export declare function pqRemove(pq: Pq): SNode | null;
+/**
+ * Update the priority of node n to d and restore heap.
+ * @see lib/ortho/fPQ.c:PQupdate
+ */
+export declare function pqUpdate(pq: Pq, n: SNode, d: number): void;
+//# sourceMappingURL=fpq.d.ts.map

package/dist/ortho/fpq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fpq.d.ts","sourceRoot":"","sources":["../../src/ortho/fpq.ts"],"names":[],"mappings":"AACA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;GAGG;AACH,MAAM,WAAW,EAAE;IACjB,EAAE,EAAE,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,CAkBpC;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,EAAE,GAAG,IAAI,CAEpC;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,CAEnC;AAoBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAQlD;AA2BD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,KAAK,GAAG,IAAI,CAW7C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAG1D"}

package/dist/ortho/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Public entry point for orthogonal edge routing.
+ *
+ * Faithful port of lib/ortho/ortho.c:orthoEdges.
+ *
+ * @see lib/ortho/ortho.c:orthoEdges
+ */
+import type { OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint } from "./types.js";
+import type { ClipAndInstallFn } from "./types.js";
+export type { OrthoGraph, OrthoEdge, OrthoNode, OrthoPoint, ClipAndInstallFn };
+export { SEED } from "./partition.js";
+/**
+ * Squared distance between the two endpoints' CENTERS — used only to order
+ * edges for routing. C uses `DIST2(ND_coord(tail), ND_coord(head))`, i.e. the
+ * node centres, NOT the bb corners: for nodes of differing width the corner-to-
+ * corner length reorders near-equal-length edges, and routing order drives maze
+ * channel occupancy (and thus corridor selection). Squared vs sqrt is immaterial
+ * to the ordering but kept squared to match C exactly.
+ *
+ * Read `coord` directly when the caller plumbed it (same fallback pattern as
+ * mkMaze's gcell derivation, maze.ts:267-268) rather than re-deriving the
+ * centre from `bb` — the bb round-trip ((c-lw)+(c+rw))/2 loses low bits versus
+ * C's raw ND_coord read and can flip a qsort tie-order on other graphs. Falls
+ * back to the bb centre only for port-less callers that don't model coord.
+ * @see lib/ortho/ortho.c:1124 (edgeLen)
+ */
+export declare function edgeLen(e: OrthoEdge): number;
+/**
+ * For edges without position information, construct an orthogonal routing.
+ * If useLbls is true, issues a warning and sets useLbls=false.
+ *
+ * @see lib/ortho/ortho.c:orthoEdges
+ */
+export declare function orthoEdges(g: OrthoGraph, useLbls: boolean, clipAndInstall?: ClipAndInstallFn): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/ortho/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ortho/index.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAE7C,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAUnD,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC;AAC/E,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAStC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,GAAG,MAAM,CAQ5C;AAgED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,OAAO,EAChB,cAAc,CAAC,EAAE,gBAAgB,GAChC,IAAI,CA2EN"}