@knowvah/dot-engine 0.1.0

package/dist/ortho/maze-channels.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Channel extraction and search for the ortho maze.
+ *
+ * @see lib/ortho/ortho.c:extractHChans, extractVChans, chanSearch
+ */
+import type { Maze, Channel, ChanDict } from "./types.js";
+import { makeGraph } from "./rawgraph.js";
+export { makeGraph };
+/** New empty two-level channel dict (outer Dtoset keyed by v). */
+export declare function newChanDict(): ChanDict;
+/**
+ * Extract horizontal channels from the maze.
+ * @see lib/ortho/ortho.c:extractHChans
+ */
+export declare function extractHChans(mp: Maze): ChanDict;
+/**
+ * Extract vertical channels from the maze.
+ * @see lib/ortho/ortho.c:extractVChans
+ */
+export declare function extractVChans(mp: Maze): ChanDict;
+/**
+ * Walk channels exactly as C's assignTracks-family loops do:
+ *   for (l1 = dtflatten(chans); l1; l1 = dtlink(chans,l1))
+ *     for (l2 = dtflatten(lp); l2; l2 = dtlink(lp,l2))
+ * dtflatten right-linearises the splay tree into a sorted chain, and dtlink
+ * follows raw `.right` pointers LIVE. When the loop body performs a
+ * chanSearch (dtmatch), the dict is unflattened and re-splayed mid-walk, so
+ * the `.right` chain the walker follows is rewritten under it — C then
+ * silently SKIPS every channel a rotation moved into a left subtree. This
+ * corrupted-walk behavior is deterministic and load-bearing for the
+ * parallel-edge pass (corpus 1447_1/osage: C visits 157 of 294 channels).
+ * The generator reads `.right` lazily at each resume, reproducing it.
+ * @see lib/ortho/ortho.c:assignTracks, add_p_edges (dtflatten walks)
+ * @see src/ortho/chan-dict.ts (flatten/unflatten mechanics)
+ */
+export declare function chansInOrder(chans: ChanDict): Generator<[number, Channel]>;
+/**
+ * Find the channel whose interval nests with the segment (chancmpid == 0).
+ * Both lookups are C dtmatch calls: they SPLAY the dicts, which is what
+ * corrupts any dtflatten walk in progress (see chansInOrder).
+ * @see lib/ortho/ortho.c:chanSearch
+ */
+export declare function chanSearch(chans: ChanDict, commCoord: number, p: {
+    p1: number;
+    p2: number;
+}): Channel | null;
+//# sourceMappingURL=maze-channels.d.ts.map

package/dist/ortho/maze-channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maze-channels.d.ts","sourceRoot":"","sources":["../../src/ortho/maze-channels.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAEH,OAAO,KAAK,EAAQ,IAAI,EAAE,OAAO,EAAY,QAAQ,EAAS,MAAM,YAAY,CAAC;AAEjF,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAG1C,OAAO,EAAE,SAAS,EAAE,CAAC;AAarB,kEAAkE;AAClE,wBAAgB,WAAW,IAAI,QAAQ,CAEtC;AAsED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,IAAI,GAAG,QAAQ,CAahD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,IAAI,GAAG,QAAQ,CAahD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAiB,YAAY,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAO3E;AAuBD;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,QAAQ,EACf,SAAS,EAAE,MAAM,EACjB,CAAC,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5B,OAAO,GAAG,IAAI,CAIhB"}

package/dist/ortho/maze.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Maze construction — mkMaze, updateWts, markSmall, createSEdges.
+ *
+ * Faithful port of lib/ortho/maze.c.
+ *
+ * @see lib/ortho/maze.c
+ * @see lib/ortho/maze.h
+ */
+import type { OrthoGraph, Cell, SEdge, SGraph, Maze } from "./types.js";
+/** @see lib/ortho/maze.c:#define MARGIN 36 */
+export declare const MARGIN = 36;
+/** @see lib/ortho/maze.c:#define BIG 16384 */
+export declare const BIG = 16384;
+/**
+ * `w` and the macro result are `double` in C (both call sites declare `hsz`/
+ * `vsz` as `double`) — the expansion is real division, not integer
+ * truncation. Do not add `Math.floor`/`Math.trunc` here.
+ * @see lib/ortho/maze.c:142 #define CHANSZ(w) (((w)-3)/2)
+ */
+export declare function chanSz(w: number): number;
+/** @see lib/ortho/maze.c:updateWts */
+export declare function updateWts(g: SGraph, cp: Cell, ep: SEdge): void;
+/** @see lib/ortho/maze.c:mkMaze */
+export declare function mkMaze(g: OrthoGraph): Maze;
+/** @see lib/ortho/maze.c:freeMaze */
+export declare function freeMaze(_mp: Maze): void;
+//# sourceMappingURL=maze.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"maze.d.ts","sourceRoot":"","sources":["../../src/ortho/maze.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACA,UAAU,EACpB,IAAI,EAAS,KAAK,EAAE,MAAM,EAAE,IAAI,EACjC,MAAM,YAAY,CAAC;AAapB,8CAA8C;AAC9C,eAAO,MAAM,MAAM,KAAK,CAAC;AAKzB,8CAA8C;AAC9C,eAAO,MAAM,GAAG,QAAQ,CAAC;AAEzB;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC;AAgBD,sCAAsC;AACtC,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,GAAG,IAAI,CAe9D;AAqMD,mCAAmC;AACnC,wBAAgB,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI,CAkC1C;AAED,qCAAqC;AACrC,wBAAgB,QAAQ,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI,CAAqB"}

package/dist/ortho/ortho-parallel.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Parallel-segment precedence edges for orthogonal track assignment.
+ *
+ * When two segments occupy the exact same channel position (`is_parallel`),
+ * `top_sort`'s default ordering is unconstrained — C resolves the tie by
+ * walking outward along each segment's route until the two chains diverge,
+ * then propagating the divergent pair's `seg_cmp` precedence back along the
+ * parallel run as explicit graph edges. Skipping this (as an earlier port
+ * revision did — see corpus 1447_1) leaves parallel tracks in whatever order
+ * `top_sort` picks by construction, which does not match the C oracle.
+ *
+ * Faithful port of `lib/ortho/ortho.c:780-1010`.
+ *
+ * @see lib/ortho/ortho.c:next_seg
+ * @see lib/ortho/ortho.c:is_parallel
+ * @see lib/ortho/ortho.c:propagate_prec
+ * @see lib/ortho/ortho.c:decide_point
+ * @see lib/ortho/ortho.c:set_parallel_edges
+ * @see lib/ortho/ortho.c:removeEdge
+ * @see lib/ortho/ortho.c:addPEdges
+ * @see lib/ortho/ortho.c:add_p_edges
+ */
+import type { ChanDict, Maze } from "./types.js";
+/** @see lib/ortho/ortho.c:add_p_edges */
+export declare function addPEdgesAll(chans: ChanDict, mp: Maze): number;
+//# sourceMappingURL=ortho-parallel.d.ts.map

package/dist/ortho/ortho-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ortho-parallel.d.ts","sourceRoot":"","sources":["../../src/ortho/ortho-parallel.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAyB,QAAQ,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AA4NxE,yCAAyC;AACzC,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAQ9D"}

package/dist/ortho/ortho-route.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Orthogonal edge routing pipeline — track assignment, segment comparison,
+ * and route conversion.
+ *
+ * Faithful port of the non-trivial helpers in lib/ortho/ortho.c.
+ *
+ * @see lib/ortho/ortho.c
+ */
+import type { OrthoSegment, Route, SGraph, SNode, Maze } from "./types.js";
+import { Bend } from "./types.js";
+import { insertEdge, edgeExists, removeRedge } from "./rawgraph.js";
+export declare const BIG = 16384;
+/** @see lib/ortho/ortho.c:setSeg */
+export declare function setSeg(dir: boolean, fix: number, b1: number, b2: number, l1: Bend, l2: Bend): OrthoSegment;
+/**
+ * Convert a shortest-path result to a sequence of routing segments.
+ * @see lib/ortho/ortho.c:convertSPtoRoute
+ */
+export declare function convertSPtoRoute(g: SGraph, fst: SNode, lst: SNode): Route;
+/** @see lib/ortho/ortho.c:assignSegs */
+export declare function assignSegs(routes: Route[], mp: Maze): void;
+/** @see lib/ortho/ortho.c:vtrack */
+export declare function vtrack(seg: OrthoSegment, mp: Maze): number;
+/** @see lib/ortho/ortho.c:htrack */
+export declare function htrack(seg: OrthoSegment, mp: Maze): number;
+/** @see lib/ortho/ortho.c:seg_cmp */
+export declare function segCmp(s1: OrthoSegment, s2: OrthoSegment): number;
+/** @see lib/ortho/ortho.c:assignTracks */
+export declare function assignTracks(mp: Maze): number;
+export { insertEdge, edgeExists, removeRedge };
+//# sourceMappingURL=ortho-route.d.ts.map

package/dist/ortho/ortho-route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ortho-route.d.ts","sourceRoot":"","sources":["../../src/ortho/ortho-route.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,YAAY,EAAE,KAAK,EAAQ,MAAM,EAAE,KAAK,EACrB,IAAI,EACxB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,IAAI,EAAoC,MAAM,YAAY,CAAC;AAGpE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAW,MAAM,eAAe,CAAC;AAS7E,eAAO,MAAM,GAAG,QAAQ,CAAC;AAIzB,oCAAoC;AACpC,wBAAgB,MAAM,CACpB,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,IAAI,GACP,YAAY,CASd;AAiCD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,KAAK,EACV,GAAG,EAAE,KAAK,GACT,KAAK,CAuCP;AAgDD,wCAAwC;AACxC,wBAAgB,UAAU,CACxB,MAAM,EAAE,KAAK,EAAE,EACf,EAAE,EAAE,IAAI,GACP,IAAI,CAQN;AAID,oCAAoC;AACpC,wBAAgB,MAAM,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAK1D;AAED,oCAAoC;AACpC,wBAAgB,MAAM,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,EAAE,IAAI,GAAG,MAAM,CAa1D;AA0ED,qCAAqC;AACrC,wBAAgB,MAAM,CAAC,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,MAAM,CAKjE;AA0CD,0CAA0C;AAC1C,wBAAgB,YAAY,CAAC,EAAE,EAAE,IAAI,GAAG,MAAM,CAU7C;AAED,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC"}

package/dist/ortho/partition.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Partition free space around nodes into rectangular tiles.
+ *
+ * Faithful port of lib/ortho/partition.c.
+ * Runs Seidel trapezoidation TWICE: once normal, once with x/y swapped
+ * (via perp()). Intersection of the two decompositions yields cells
+ * bounded on all four sides.
+ *
+ * SEED is fixed at 173 — matches lib/ortho/partition.c:srand48(173).
+ *
+ * @see lib/ortho/partition.c
+ */
+import type { OrthoBox, Cell } from "./types.js";
+import type { SegmentT, TrapT } from "./trapezoid.js";
+/** Fixed RNG seed — matches lib/ortho/partition.c:srand48(173) */
+declare const SEED = 173;
+export { SEED };
+/** @see lib/ortho/partition.c:#define TR_FROM_UP/TR_FROM_DN */
+declare const TR_FROM_UP = 1;
+declare const TR_FROM_DN = 2;
+/**
+ * Partition free space around cells into rectangular tiles.
+ * @see lib/ortho/partition.c:partition
+ */
+export declare function partition(cells: Cell[], bb: OrthoBox): OrthoBox[];
+/**
+ * Test-only accessor for `PartitionHelper.childOrder` — exposes the
+ * traverse_polygon branch-table transcription for direct unit testing
+ * without requiring a full trapezoidation pipeline to exercise each branch.
+ * @see PartitionHelper.childOrder
+ */
+export declare function traverseChildOrderForTest(t: TrapT, seg: SegmentT[], from: number, dir: number): [number, number][];
+export { TR_FROM_UP, TR_FROM_DN };
+//# sourceMappingURL=partition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"partition.d.ts","sourceRoot":"","sources":["../../src/ortho/partition.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAc,IAAI,EAAE,MAAM,YAAY,CAAC;AAI7D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEtD,kEAAkE;AAClE,QAAA,MAAM,IAAI,MAAM,CAAC;AAEjB,OAAO,EAAE,IAAI,EAAE,CAAC;AAIhB,+DAA+D;AAC/D,QAAA,MAAM,UAAU,IAAI,CAAC;AACrB,QAAA,MAAM,UAAU,IAAI,CAAC;AAoOrB;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,QAAQ,GAAG,QAAQ,EAAE,CA0BjE;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GACnD,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAEpB;AAED,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC"}

package/dist/ortho/rawgraph.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Directed graph with DFS-based topological sort.
+ *
+ * Faithful port of lib/ortho/rawgraph.c.
+ * @see lib/ortho/rawgraph.c
+ * @see lib/ortho/rawgraph.h
+ */
+import type { RawGraph } from "./types.js";
+/**
+ * Allocate a graph with n vertices and no edges.
+ * @see lib/ortho/rawgraph.c:make_graph
+ */
+export declare function makeGraph(n: number): RawGraph;
+/**
+ * Release all memory associated with the graph.
+ * (No-op in TS — GC handles it; retained for API symmetry.)
+ * @see lib/ortho/rawgraph.c:free_graph
+ */
+export declare function freeGraph(_g: RawGraph): void;
+/**
+ * Insert a directed edge from v1 to v2 (if it doesn't exist yet).
+ * @see lib/ortho/rawgraph.c:insert_edge
+ */
+export declare function insertEdge(g: RawGraph, v1: number, v2: number): void;
+/**
+ * Remove any edge between v1 and v2 (either direction).
+ * @see lib/ortho/rawgraph.c:remove_redge
+ */
+export declare function removeRedge(g: RawGraph, v1: number, v2: number): void;
+/**
+ * Test if there is a directed edge FROM v1 TO v2.
+ * @see lib/ortho/rawgraph.c:edge_exists
+ */
+export declare function edgeExists(g: RawGraph, v1: number, v2: number): boolean;
+/**
+ * Topologically sort the directed graph.
+ * After this call, each vertex has topsortOrder set.
+ * @see lib/ortho/rawgraph.c:top_sort
+ */
+export declare function topSort(g: RawGraph): void;
+//# sourceMappingURL=rawgraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rawgraph.d.ts","sourceRoot":"","sources":["../../src/ortho/rawgraph.ts"],"names":[],"mappings":"AACA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,YAAY,CAAC;AAMtD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ,CAM7C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAE5C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAIpE;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAGrE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvE;AA4BD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAwBzC"}

package/dist/ortho/sgraph.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Search graph and Dijkstra shortest path for ortho edge routing.
+ *
+ * Faithful port of lib/ortho/sgraph.c.
+ * Distance values stored NEGATED in nVal while in the priority queue.
+ * When a node is finalized (popped), nVal is flipped positive.
+ * UNSEEN = Number.MIN_SAFE_INTEGER (mirrors C INT_MIN).
+ *
+ * @see lib/ortho/sgraph.c
+ * @see lib/ortho/sgraph.h
+ */
+import type { SGraph, SNode, SEdge, Cell } from "./types.js";
+import { pqFree } from "./fpq.js";
+import type { Pq } from "./fpq.js";
+/** Sentinel value for unseen nodes. @see lib/ortho/sgraph.c:UNSEEN */
+export declare const UNSEEN: number;
+/**
+ * Allocate a search graph with capacity for nnodes nodes (+2 dummy slots).
+ * @see lib/ortho/sgraph.c:createSGraph
+ */
+export declare function createSGraph(nnodes: number): SGraph;
+/**
+ * Free the graph. (No-op in TS — GC handles it.)
+ * @see lib/ortho/sgraph.c:freeSGraph
+ */
+export declare function freeSGraph(_g: SGraph): void;
+/**
+ * Initialize per-node adjacency list storage.
+ * Regular nodes get 6 slots; the two dummy nodes get maxdeg slots each.
+ * @see lib/ortho/sgraph.c:initSEdges
+ */
+export declare function initSEdges(g: SGraph, maxdeg: number): void;
+/**
+ * Append a new node to the graph and return it.
+ * @see lib/ortho/sgraph.c:createSNode
+ */
+export declare function createSNode(g: SGraph): SNode;
+/**
+ * Create an edge between v1 and v2 with the given weight.
+ * @see lib/ortho/sgraph.c:createSEdge
+ */
+export declare function createSEdge(g: SGraph, v1: SNode, v2: SNode, wt: number): SEdge;
+/**
+ * Save the current graph state (node/edge counts + adjacency counts).
+ * @see lib/ortho/sgraph.c:gsave
+ */
+export declare function gsave(g: SGraph): void;
+/**
+ * Restore the graph to the last saved state and clear the two dummy nodes.
+ * @see lib/ortho/sgraph.c:reset
+ */
+export declare function reset(g: SGraph): void;
+/** Dijkstra shortest path from `from` to `to`; 0 on success, 1 on PQ overflow.
+ * Distances stored NEGATED while pending, flipped positive when finalized.
+ * @see lib/ortho/sgraph.c:shortPath */
+export declare function shortPath(pq: Pq, g: SGraph, from: SNode, to: SNode): number;
+/**
+ * Generate a fresh priority queue sized for the search graph.
+ * @see lib/ortho/sgraph.c shortPath preamble
+ */
+export declare function pqGenForGraph(g: SGraph): Pq;
+export { pqFree };
+/**
+ * Add temporary edges from a node cell to the search graph.
+ * Used to attach source/dest nodes before each Dijkstra call.
+ * @see lib/ortho/ortho.c:addNodeEdges
+ */
+export declare function addNodeEdges(sg: SGraph, cp: Cell, np: SNode): void;
+/**
+ * Add temporary loop edges (self-loop at a single cell).
+ * @see lib/ortho/ortho.c:addLoop
+ */
+export declare function addLoop(sg: SGraph, cp: Cell, dp: SNode, sp: SNode): void;
+//# sourceMappingURL=sgraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sgraph.d.ts","sourceRoot":"","sources":["../../src/ortho/sgraph.ts"],"names":[],"mappings":"AACA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAS,MAAM,EAAwC,MAAM,UAAU,CAAC;AAC/E,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC,sEAAsE;AACtE,eAAO,MAAM,MAAM,QAA0B,CAAC;AAI9C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAanD;AAoBD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAyB1D;AAID;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAK5C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,KAAK,EACT,EAAE,EAAE,KAAK,EACT,EAAE,EAAE,MAAM,GACT,KAAK,CAcP;AAID;;;GAGG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAMrC;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAYrC;AAqCD;;uCAEuC;AACvC,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,CAkB3E;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,EAAE,CAE3C;AAED,OAAO,EAAE,MAAM,EAAE,CAAC;AAIlB;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,KAAK,GACR,IAAI,CAUN;AAED;;;GAGG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,KAAK,EACT,EAAE,EAAE,KAAK,GACR,IAAI,CAaN"}

package/dist/ortho/trap-query.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Query-structure operations for Seidel trapezoidation:
+ * locate_endpoint, is_left_of, inserted.
+ *
+ * @see lib/ortho/trapezoid.c
+ */
+import { isValidTrap, TRAP_MAX } from "./trap-types.js";
+import type { SegPoint, SegmentT, TrapT, QNode } from "./trap-types.js";
+/**
+ * Test whether point v is to the left of segment segnum.
+ * @see lib/ortho/trapezoid.c:is_left_of
+ */
+export declare function isLeftOf(segnum: number, seg: SegmentT[], v: SegPoint): boolean;
+/**
+ * Whether the given endpoint of segnum is already inserted.
+ * @see lib/ortho/trapezoid.c:inserted
+ */
+export declare function inserted(segnum: number, seg: SegmentT[], whichpt: number): boolean;
+/**
+ * Which trapezoid contains point v?
+ * @see lib/ortho/trapezoid.c:locate_endpoint
+ */
+export declare function locateEndpoint(v: SegPoint, vo: SegPoint, r: number, seg: SegmentT[], qs: QNode[]): number;
+/**
+ * Merge trapezoids sharing common segments on one side.
+ * @see lib/ortho/trapezoid.c:merge_trapezoids
+ */
+export declare function mergeTrapezoids(segnum: number, tfirst: number, tlast: number, side: number, tr: TrapT[], qs: QNode[]): void;
+import { greaterThanOrEq } from "./trap-types.js";
+export { greaterThanOrEq };
+export { TRAP_MAX, isValidTrap };
+//# sourceMappingURL=trap-query.d.ts.map

package/dist/ortho/trap-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trap-query.d.ts","sourceRoot":"","sources":["../../src/ortho/trap-query.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EAG0B,WAAW,EACnC,QAAQ,EAChB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,EAAE,EACf,CAAC,EAAE,QAAQ,GACV,OAAO,CAaT;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,EAAE,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAGT;AAyBD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,QAAQ,EACX,EAAE,EAAE,QAAQ,EACZ,CAAC,EAAE,MAAM,EACT,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,GACV,MAAM,CAeR;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,KAAK,EAAE,GACV,IAAI,CAgBN;AAyCD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/ortho/trap-segment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * add_segment and its helpers for Seidel trapezoidation.
+ *
+ * @see lib/ortho/trapezoid.c:add_segment
+ */
+import type { SegmentT, TrapT, QNode } from "./trap-types.js";
+export declare function insertV0(s: SegmentT, seg: SegmentT[], tr: TrapT[], qs: QNode[], segnum: number): number;
+export declare function insertV1(s: SegmentT, seg: SegmentT[], tr: TrapT[], qs: QNode[], segnum: number): number;
+export declare function handleD0Only(s: SegmentT, seg: SegmentT[], tr: TrapT[], t: number, tn: number, tlast: number, segnum: number, isSwapped: boolean, tribot: boolean): void;
+export declare function handleD1Only(s: SegmentT, seg: SegmentT[], tr: TrapT[], t: number, tn: number, tlast: number, segnum: number, isSwapped: boolean, tribot: boolean): void;
+export declare function handleBothD(s: SegmentT, seg: SegmentT[], tr: TrapT[], t: number, tn: number, tlast: number, tribot: boolean): number;
+export declare function swapSegEndpoints(s: SegmentT): void;
+/**
+ * Insert one segment into the trapezoidation.
+ * @see lib/ortho/trapezoid.c:add_segment
+ */
+export declare function addSegment(segnum: number, seg: SegmentT[], tr: TrapT[], qs: QNode[]): void;
+/**
+ * Update root pointers for each segment endpoint after a batch of insertions.
+ * @see lib/ortho/trapezoid.c:find_new_roots
+ */
+export declare function findNewRoots(segnum: number, seg: SegmentT[], tr: TrapT[], qs: QNode[]): void;
+//# sourceMappingURL=trap-segment.d.ts.map

package/dist/ortho/trap-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trap-segment.d.ts","sourceRoot":"","sources":["../../src/ortho/trap-segment.ts"],"names":[],"mappings":"AACA;;;;GAIG;AASH,OAAO,KAAK,EAAY,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAMxE,wBAAgB,QAAQ,CACtB,CAAC,EAAE,QAAQ,EACX,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,KAAK,EAAE,EACX,MAAM,EAAE,MAAM,GACb,MAAM,CAUR;AA2BD,wBAAgB,QAAQ,CACtB,CAAC,EAAE,QAAQ,EACX,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,KAAK,EAAE,EACX,MAAM,EAAE,MAAM,GACb,MAAM,CAUR;AA8BD,wBAAgB,YAAY,CAC1B,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EACzC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EACpC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAClD,IAAI,CAQN;AAED,wBAAgB,YAAY,CAC1B,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EACzC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EACpC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAClD,IAAI,CAQN;AAgBD,wBAAgB,WAAW,CACzB,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EACzC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GACpD,MAAM,CAIR;AAiCD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI,CAGlD;AAID;;;GAGG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,KAAK,EAAE,GACV,IAAI,CA2BN;AAsDD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,EACX,EAAE,EAAE,KAAK,EAAE,GACV,IAAI,CAKN"}

package/dist/ortho/trap-types.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Trapezoid types and floating-point helpers for Seidel trapezoidation.
+ *
+ * @see lib/ortho/trap.h
+ */
+/** Tolerance for floating-point equality. @see lib/ortho/trap.h:C_EPS */
+export declare const C_EPS = 1e-7;
+/** Sentinel for unset trap indices — mirrors C SIZE_MAX. */
+export declare const TRAP_MAX: number;
+/** Sentinel for invalid/absent trap — mirrors C 0. */
+export declare const INVALID_TRAP = 0;
+export declare const S_LEFT = 1;
+export declare const S_RIGHT = 2;
+export declare const T_X = 1;
+export declare const T_Y = 2;
+export declare const T_SINK = 3;
+export declare const FIRSTPT = 1;
+export declare const LASTPT = 2;
+export interface SegPoint {
+    x: number;
+    y: number;
+}
+/**
+ * A polygon boundary segment.
+ * @see lib/ortho/trap.h:segment_t
+ */
+export interface SegmentT {
+    v0: SegPoint;
+    v1: SegPoint;
+    isInserted: boolean;
+    root0: number;
+    root1: number;
+    next: number;
+    prev: number;
+}
+/**
+ * A trapezoid in the decomposition.
+ * @see lib/ortho/trap.h:trap_t
+ */
+export interface TrapT {
+    lseg: number;
+    rseg: number;
+    hi: SegPoint;
+    lo: SegPoint;
+    u0: number;
+    u1: number;
+    d0: number;
+    d1: number;
+    sink: number;
+    usave: number;
+    uside: number;
+    isValid: boolean;
+}
+/** Query-tree node. */
+export interface QNode {
+    nodetype: number;
+    segnum: number;
+    yval: SegPoint;
+    trnum: number;
+    parent: number;
+    left: number;
+    right: number;
+}
+/** @see lib/ortho/trap.h:is_valid_trap */
+export declare function isValidTrap(index: number): boolean;
+/** @see lib/ortho/trap.h:fp_equal */
+export declare function fpEqual(s: number, t: number): boolean;
+/** @see lib/ortho/trap.h:dfp_cmp */
+export declare function dfpCmp(f1: number, f2: number): number;
+/** @see lib/ortho/trap.h:equal_to */
+export declare function equalTo(v0: SegPoint, v1: SegPoint): boolean;
+/** @see lib/ortho/trap.h:greater_than */
+export declare function greaterThan(v0: SegPoint, v1: SegPoint): boolean;
+export declare function greaterThanOrEq(v0: SegPoint, v1: SegPoint): boolean;
+export declare function lessThan(v0: SegPoint, v1: SegPoint): boolean;
+export declare function maxPt(v0: SegPoint, v1: SegPoint): SegPoint;
+export declare function minPt(v0: SegPoint, v1: SegPoint): SegPoint;
+export declare function cross(v0: SegPoint, v1: SegPoint, v2: SegPoint): number;
+export declare function newQNode(qs: QNode[]): number;
+export declare function newTrap(tr: TrapT[]): number;
+/**
+ * Number of times log₂ must be applied before result < 1.
+ * @see lib/ortho/trapezoid.c:math_logstar_n
+ */
+export declare function mathLogstarN(n: number): number;
+/**
+ * ceil(n / log^(h)(n))
+ * @see lib/ortho/trapezoid.c:math_N
+ */
+export declare function mathN(n: number, h: number): number;
+//# sourceMappingURL=trap-types.d.ts.map

package/dist/ortho/trap-types.d.ts.map

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

package/dist/ortho/trap-update.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trapezoid update logic — updateTrapezoid and its helpers.
+ *
+ * @see lib/ortho/trapezoid.c:update_trapezoid
+ */
+import type { SegmentT, TrapT } from "./trap-types.js";
+/**
+ * Update upper-neighbour pointers when threading a segment through t and tn.
+ * @see lib/ortho/trapezoid.c:update_trapezoid
+ */
+export declare function updateTrapezoid(s: SegmentT, seg: SegmentT[], tr: TrapT[], t: number, tn: number): void;
+//# sourceMappingURL=trap-update.d.ts.map

package/dist/ortho/trap-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trap-update.d.ts","sourceRoot":"","sources":["../../src/ortho/trap-update.ts"],"names":[],"mappings":"AACA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAGvD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,QAAQ,EACX,GAAG,EAAE,QAAQ,EAAE,EACf,EAAE,EAAE,KAAK,EAAE,EACX,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,GACT,IAAI,CAMN"}

package/dist/ortho/trapezoid.d.ts

@@ -0,0 +1,18 @@
+/**
+ * construct_trapezoids — main entry point for Seidel trapezoidation.
+ * Also re-exports the public surface used by partition.ts.
+ *
+ * @see lib/ortho/trapezoid.c:construct_trapezoids
+ */
+import { mathLogstarN, mathN, isValidTrap } from "./trap-types.js";
+import type { SegmentT, TrapT, QNode } from "./trap-types.js";
+export type { SegmentT, TrapT };
+export { isValidTrap, mathLogstarN, mathN };
+export type { QNode };
+export { fpEqual, equalTo, greaterThan, dfpCmp, C_EPS, } from "./trap-types.js";
+/**
+ * Build the trapezoidal decomposition of the polygon defined by seg[1..nseg].
+ * @see lib/ortho/trapezoid.c:construct_trapezoids
+ */
+export declare function constructTrapezoids(nseg: number, seg: SegmentT[], permute: number[]): TrapT[];
+//# sourceMappingURL=trapezoid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trapezoid.d.ts","sourceRoot":"","sources":["../../src/ortho/trapezoid.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,OAAO,EACL,YAAY,EAAE,KAAK,EAAW,WAAW,EAC1C,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG9D,YAAY,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAChC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;AAC5C,YAAY,EAAE,KAAK,EAAE,CAAC;AAGtB,OAAO,EACL,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,GAC7C,MAAM,iBAAiB,CAAC;AAEzB;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,QAAQ,EAAE,EACf,OAAO,EAAE,MAAM,EAAE,GAChB,KAAK,EAAE,CAqCT"}