@knowvah/dot-engine 0.1.0

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

@@ -0,0 +1,207 @@
+/**
+ * Neato layout initialisation helpers.
+ *
+ * Ports lib/neatogen/neatoinit.c: neato_init_node, user_pos, setSeed,
+ * solveModel, neatoTranslate, neatoSetAspect, neatoCleanup.
+ *
+ * @see lib/neatogen/neatoinit.c
+ * @see lib/neatogen/neatoprocs.h
+ */
+import type { Graph } from '../../model/graph.js';
+import type { Node } from '../../model/node.js';
+import type { Edge } from '../../model/edge.js';
+import type { VtxData } from './dijkstra.js';
+/** Kamada-Kawai energy minimization. @see lib/neatogen/neatoprocs.h */
+export declare const MODE_KK = 0;
+/** Stress majorization (default). @see lib/neatogen/neatoprocs.h */
+export declare const MODE_MAJOR = 1;
+/** Hierarchical stress majorization (digcola). @see lib/neatogen/neatoprocs.h */
+export declare const MODE_HIER = 2;
+/** IPSEP-cola constraint solver. @see lib/neatogen/neatoprocs.h */
+export declare const MODE_IPSEP = 3;
+/** Stochastic gradient descent. @see lib/neatogen/neatoprocs.h */
+export declare const MODE_SGD = 4;
+/** Shortest-path distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_SHORTPATH = 0;
+/** Circuit resistance distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_CIRCUIT = 1;
+/** Subset / Jaccard distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_SUBSET = 2;
+/** MDS distance model. @see lib/neatogen/defs.h */
+export declare const MODEL_MDS = 3;
+/**
+ * Initialise a node for neato layout.
+ *
+ * Ensures pos is a number[] of length dim, sets default UF_size, width,
+ * and height.
+ *
+ * @see lib/neatogen/neatoinit.c:neato_init_node
+ */
+export declare function neatoInitNode(n: Node, dim?: number): void;
+/**
+ * Seed a node's initial position from its `pos=` attribute (C's P_SET),
+ * mirroring user_pos. Sets info.pos + info.posSet so hasPos is true and neato
+ * majorization starts from the input layout instead of a random init; a `!`
+ * suffix or `pin=true` additionally sets info.pinned (P_PIN → isFixed).
+ *
+ * PSinputscale (the `inputscale` attr) is not tracked — the suite has
+ * PSinputscale <= 0, so positions stay in points exactly as native leaves them
+ * (a `pos="27,42"` seeds (27,42), which orthog1 then centres). Must run AFTER
+ * neatoInitNode, which zeroes info.pos.
+ * @see lib/neatogen/neatoinit.c:user_pos
+ */
+export declare function userPos(n: Node): boolean;
+/**
+ * Classify the first character of `p` as 'alpha', 'digit', or 'other'.
+ *
+ * @see lib/neatogen/neatoinit.c:setSeed (gv_isalpha / gv_isdigit checks)
+ */
+export declare function classifyFirstChar(p: string): 'alpha' | 'digit' | 'other';
+/**
+ * Detect a recognised alpha keyword prefix in `p`.
+ * Returns `{ rest, matched }` where `matched` is 'random' | null.
+ * 'self' and 'regular' are treated as non-random (seed stays 0).
+ *
+ * @see lib/neatogen/neatoinit.c:setSeed (keyword detection block)
+ */
+export declare function parseSeedPrefix(p: string): {
+    rest: string;
+    matched: string | null;
+};
+/**
+ * Parse `rest` as an integer seed; returns 0 if not parseable.
+ *
+ * @see lib/neatogen/neatoinit.c:setSeed (seed numeric suffix)
+ */
+export declare function parseSeedInt(rest: string): number;
+/**
+ * Parse the `g.info.start` string attribute to set the RNG seed.
+ *
+ * Returns defaultMode in all cases (the C function also returns init mode,
+ * but for the neato pipeline mode is resolved separately).
+ * Sets `seed.value` as a side-effect.
+ *
+ * @see lib/neatogen/neatoinit.c:setSeed
+ */
+export declare function setSeed(g: Graph, defaultMode: number, seed: {
+    value: number;
+}): number;
+/**
+ * Assign sequential IDs to all nodes and return them in insertion order.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData (node ID assignment pass)
+ */
+export declare function assignNodeIds(g: Graph): Node[];
+/**
+ * Allocate one self-loop VtxData entry per node.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData (graph[] init)
+ */
+export declare function initVtxEntries(nodeList: Node[]): VtxData[];
+/**
+ * Resolve edge weight: factor takes priority, then weight, then 1.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData (ED_factor usage)
+ */
+export declare function edgeWeight(e: Edge): number;
+/**
+ * Add a bidirectional edge between two VtxData entries with weight w.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData (edge insertion loop)
+ */
+export declare function addEdgeToVtx(vtx: VtxData[], ti: number, hi: number, w: number): void;
+/**
+ * Insert all non-self-loop edges from `g` into `vtx`.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData (edge loop)
+ */
+export declare function addGraphEdges(g: Graph, vtx: VtxData[]): void;
+/**
+ * Assign sequential node IDs and build VtxData sparse graph.
+ *
+ * @see lib/neatogen/neatoinit.c:makeGraphData
+ */
+export declare function buildVtxData(g: Graph): VtxData[];
+/**
+ * Copy node positions from `n.info.pos` into per-axis Float64Array.
+ *
+ * @see lib/neatogen/neatoinit.c:majorization (coords allocation)
+ */
+export declare function buildDCoords(nodeList: Node[], dim: number): Float64Array[];
+/**
+ * Write per-axis Float64Array results back into `n.info.pos`.
+ *
+ * @see lib/neatogen/neatoinit.c:majorization (write-back loop)
+ */
+export declare function writeBackCoords(nodeList: Node[], dCoords: Float64Array[], dim: number): void;
+/**
+ * Map init.ts model constants to stress.ts model constants.
+ * Both use the same numeric values but are distinct exports.
+ */
+export declare function mapModelToStress(model: number): number;
+/**
+ * Run stress majorization on the graph and write results back to node positions.
+ *
+ * @see lib/neatogen/neatoinit.c:majorization
+ */
+export declare function runMajorization(g: Graph, mode: number, model: number): void;
+/** Any edge carries a len attr (C: agattr_text(g, AGEDGE, "len")). */
+export declare function graphHasLen(g: Graph): boolean;
+/**
+ * Seed the RNG from the start attr; no attr means the default seed 1.
+ * start=regular/self are not ported (no suite input uses them).
+ * @see lib/neatogen/neatoinit.c:setSeed
+ * @see lib/neatogen/neatoinit.c:checkStart
+ */
+export declare function checkStart(g: Graph): void;
+/**
+ * Build the vtx_data adjacency in C's makeGraphData shape: per node,
+ * out-edges then in-edges (agfstedge order), self entry at index 0,
+ * duplicate neighbours merged (len keeps the max). ewgts are edge
+ * lens (default 1.0) when any len attr exists, else absent so the
+ * APSP uses BFS hop counts.
+ * @see lib/neatogen/neatoinit.c:makeGraphData
+ * @see lib/neatogen/stuff.c:setEdgeLen
+ */
+export declare function makeGraphDataC(g: Graph, nodeList: Node[], haveLen: boolean): VtxData[];
+/**
+ * Dispatch to the appropriate layout solver for the given mode.
+ *
+ * @see lib/neatogen/neatoinit.c:neatoLayout
+ */
+export declare function solveModel(g: Graph, mode: number, model: number): void;
+/**
+ * Find minimum X and Y across all node positions.
+ *
+ * @see lib/neatogen/neatoinit.c (translate logic)
+ */
+export declare function findMinPos(g: Graph): {
+    minX: number;
+    minY: number;
+};
+/**
+ * Subtract (dx, dy) from every node position in place.
+ *
+ * @see lib/neatogen/neatoinit.c (translate loop)
+ */
+export declare function shiftPositions(g: Graph, dx: number, dy: number): void;
+/**
+ * Shift all node positions so the minimum is at (0, 0).
+ *
+ * @see lib/neatogen/neatoinit.c (translate logic inside neato_layout /
+ *      gv_postprocess)
+ */
+export declare function neatoTranslate(g: Graph): void;
+/**
+ * Copy position (inches) to coord (points, multiply by 72).
+ *
+ * @see lib/neatogen/neatoinit.c (position-to-coord conversion)
+ */
+export declare function neatoSetAspect(g: Graph): void;
+/**
+ * Clear neato-specific state on nodes.
+ *
+ * @see lib/neatogen/neatoinit.c:neato_cleanup
+ */
+export declare function neatoCleanup(g: Graph): void;
+//# sourceMappingURL=init.d.ts.map

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

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

package/dist/layout/neato/legal.d.ts

@@ -0,0 +1,7 @@
+import type { Poly } from '../../pathplan/types.js';
+/**
+ * True when no two obstacle polygons intersect or nest.
+ * @see lib/neatogen/legal.c:Plegal_arrangement
+ */
+export declare function legalArrangement(polys: Poly[]): boolean;
+//# sourceMappingURL=legal.d.ts.map

package/dist/layout/neato/legal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legal.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/legal.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AA6QpD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAyBvD"}

package/dist/layout/neato/matrix-ops.d.ts

@@ -0,0 +1,28 @@
+/** Subtract the mean (double precision). @see matrix_ops.c:orthog1 */
+export declare function orthog1(n: number, vec: Float64Array): void;
+/** Subtract the mean (float precision). @see matrix_ops.c:orthog1f */
+export declare function orthog1f(n: number, vec: Float32Array): void;
+/**
+ * result = packed_matrix * vector, packed upper-triangular symmetric.
+ * @see matrix_ops.c:right_mult_with_vector_ff
+ */
+export declare function rightMultWithVectorFF(m: Float32Array, n: number, vector: Float32Array, result: Float32Array): void;
+/** result = v1 - v2. @see matrix_ops.c:vectors_subtractionf */
+export declare function vectorsSubtractionF(n: number, v1: Float32Array, v2: Float32Array, result: Float32Array): void;
+/** v1 += alpha * v2 (float alpha). @see matrix_ops.c:vectors_mult_additionf */
+export declare function vectorsMultAdditionF(n: number, v1: Float32Array, alpha: number, v2: Float32Array): void;
+/** Double-precision dot product of float vectors. @see matrix_ops.c:vectors_inner_productf */
+export declare function vectorsInnerProductF(n: number, v1: Float32Array, v2: Float32Array): number;
+/** @see matrix_ops.c:copy_vectorf */
+export declare function copyVectorF(n: number, src: Float32Array, dst: Float32Array): void;
+/** @see matrix_ops.c:max_absf */
+export declare function maxAbsF(n: number, vec: Float32Array): number;
+/** @see matrix_ops.c:square_vec */
+export declare function squareVec(n: number, vec: Float32Array): void;
+/** @see matrix_ops.c:invert_vec */
+export declare function invertVec(n: number, vec: Float32Array): void;
+/** target = sqrtf(source) where source >= 0. @see matrix_ops.c:sqrt_vecf */
+export declare function sqrtVecF(n: number, source: Float32Array, target: Float32Array): void;
+/** vec = 1/sqrtf(vec) where vec > 0. @see matrix_ops.c:invert_sqrt_vec */
+export declare function invertSqrtVec(n: number, vec: Float32Array): void;
+//# sourceMappingURL=matrix-ops.d.ts.map

package/dist/layout/neato/matrix-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-ops.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/matrix-ops.ts"],"names":[],"mappings":"AAcA,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAK1D;AAED,sEAAsE;AACtE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAK3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GACrE,IAAI,CAYN;AAED,+DAA+D;AAC/D,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GAClE,IAAI,CAEN;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,GAC3D,IAAI,CAGN;AAED,8FAA8F;AAC9F,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,EAAE,EAAE,YAAY,GAAG,MAAM,CAI1F;AAED,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAEjF;AAED,iCAAiC;AACjC,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAO5D;AAED,mCAAmC;AACnC,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAE5D;AAED,mCAAmC;AACnC,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAI5D;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAIpF;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,IAAI,CAIhE"}

package/dist/layout/neato/multispline-router.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Triangle-graph router for multisplines — mkRouter and the shortest-path
+ * machinery of multispline.c.
+ *
+ * The router triangulates the free space around the obstacles (constrained
+ * Delaunay of a margined bounding box + obstacle boundaries, holes removed)
+ * and builds a graph whose nodes are triangles, connected when they share
+ * a side. Edge endpoints are added as temporary nodes connected to the
+ * triangles of their obstacle's sides, and a Dijkstra pass (max-heap on
+ * negated distances, exactly the C fPQ) finds the corridor of triangles
+ * the spline must thread.
+ *
+ * @see lib/neatogen/multispline.c:mkRouter / mkTriGraph / triPath / addEndpoint
+ * @see lib/neatogen/fPQ.h
+ */
+import type { Point, Poly } from '../../pathplan/types.js';
+/** index pair. @see multispline.c:ipair */
+export interface Ipair {
+    i: number;
+    j: number;
+}
+/** @see multispline.c:tnode */
+export interface Tnode {
+    edges: number[];
+    ctr: Point;
+}
+/** @see multispline.c:tedge */
+export interface Tedge {
+    t: number;
+    h: number;
+    seg: Ipair;
+    dist: number;
+}
+/** @see multispline.c:tgraph */
+export interface Tgraph {
+    nodes: Tnode[];
+    edges: Tedge[];
+}
+/** @see multispline.c:router_s */
+export interface Router {
+    pn: number;
+    ps: Point[];
+    /** indices in obstacle i are obs[i]...obs[i+1]-1 */
+    obs: number[];
+    /** vertex indices of triangle i: tris[3i..3i+2] */
+    tris: number[];
+    /** map from obstacle side (a,b), a<b, to adjacent kept triangle */
+    trimap: Map<number, number>;
+    /** number of triangle nodes (endpoint nodes get tn, tn+1) */
+    tn: number;
+    tg: Tgraph;
+}
+/** @see multispline.c:addTriEdge */
+export declare function addTriEdge(g: Tgraph, t: number, h: number, seg: Ipair): void;
+/**
+ * Build the router over the obstacle set: margined bbox stored CCW,
+ * obstacles CW (as given), all boundary sides as directed constraints.
+ * @see multispline.c:mkRouter
+ */
+export declare function mkRouter(obsp: Poly[]): Router;
+/** @see multispline.c:findMap */
+export declare function findMap(trimap: Map<number, number>, a: number, b: number): number;
+/** check if ray v->w intersects segment a--b. @see multispline.c:raySeg */
+export declare function raySeg(v: Point, w: Point, a: Point, b: Point): boolean;
+/**
+ * Add graph node v_id at endpoint p inside obstacle obsId, connected to the
+ * triangles adjacent to the obstacle's sides — restricted to a 45°-widened
+ * cone when p sits on specific node sides.
+ * @see multispline.c:addEndpoint
+ */
+export declare function addEndpoint(rtr: Router, p: Point, obsId: number, vId: number, sides: number): void;
+/** @see multispline.c:edgeToSeg */
+export declare function edgeToSeg(tg: Tgraph, i: number, j: number): Ipair;
+/**
+ * Shortest triangle path from v0 to v1; the result vector encodes the path
+ * v1, dad[v1], ..., v0. Null on heap overflow (cannot happen at our sizes).
+ * @see multispline.c:triPath
+ */
+export declare function triPath(g: Tgraph, n: number, v0: number, v1: number): number[] | null;
+//# sourceMappingURL=multispline-router.d.ts.map

package/dist/layout/neato/multispline-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multispline-router.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/multispline-router.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAI3D,2CAA2C;AAC3C,MAAM,WAAW,KAAK;IAAG,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE;AAE/C,+BAA+B;AAC/B,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,KAAK,CAAC;CACZ;AAED,+BAA+B;AAC/B,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,KAAK,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd;AAED,gCAAgC;AAChC,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,KAAK,EAAE,CAAC;IACf,KAAK,EAAE,KAAK,EAAE,CAAC;CAChB;AAED,kCAAkC;AAClC,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,KAAK,EAAE,CAAC;IACZ,oDAAoD;IACpD,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,mDAAmD;IACnD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,mEAAmE;IACnE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AA4BD,oCAAoC;AACpC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,GAAG,IAAI,CAQ5E;AAwBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,CAkE7C;AAED,iCAAiC;AACjC,wBAAgB,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIjF;AAkBD,2EAA2E;AAC3E,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,OAAO,CAQtE;AA6BD;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAC/D,IAAI,CAkBN;AAED,mCAAmC;AACnC,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAOjE;AA4FD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CA8BrF"}

package/dist/layout/neato/multispline.d.ts

@@ -0,0 +1,24 @@
+/**
+ * makeMultiSpline — the HAVE_GTS router of the reference binary for edges
+ * with multiplicity (ED_count > 1) or boundary ports.
+ *
+ * The triangle corridor from triPath is turned into a simple polygon
+ * (mkPoly), the shortest path inside it (Pshortestpath funnel) guides the
+ * spline, and for multi-edges each member gets its own sub-polygon built
+ * from control points fanned across the corridor (mkCtrlPts).
+ *
+ * @see lib/neatogen/multispline.c
+ */
+import type { Edge } from '../../model/edge.js';
+import type { Graph } from '../../model/graph.js';
+import type { Point } from '../../pathplan/types.js';
+import type { Router } from './multispline-router.js';
+export type { Router } from './multispline-router.js';
+export { mkRouter } from './multispline-router.js';
+/**
+ * Route edge e (and its coalesced cohorts) through the triangle router.
+ * `route` is the edge's ED_path (obsPath result). Returns 0 on success.
+ * @see multispline.c:makeMultiSpline
+ */
+export declare function makeMultiSpline(g: Graph, e: Edge, rtr: Router, route: Point[], doPolyline: boolean): number;
+//# sourceMappingURL=multispline.d.ts.map

package/dist/layout/neato/multispline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multispline.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/multispline.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAQrD,OAAO,KAAK,EAAE,MAAM,EAAS,MAAM,yBAAyB,CAAC;AAG7D,YAAY,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AA0WnD;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,OAAO,GAClE,MAAM,CA6BR"}

package/dist/layout/neato/overlap-prism.d.ts

@@ -0,0 +1,26 @@
+/**
+ * PRISM overlap removal — the HAVE_GTS remove_overlap of the reference
+ * binary. `overlap=false` (and any unrecognized overlap value) maps to
+ * AM_PRISM on that build, so circo/twopi/neato-family layouts run this
+ * after positioning.
+ *
+ * Pipeline per try: proximity graph = Delaunay triangulation of the node
+ * centers (call_tri) plus, after the first convergence, the scan-line
+ * overlap graph; ideal distances stretch overlapping pairs apart; one
+ * stress-majorization step (CG solve) moves the nodes.
+ *
+ * @see lib/neatogen/overlap.c
+ * @see lib/sfdpgen/post_process.c:StressMajorizationSmoother_smooth
+ */
+import type { SpMatrix } from '../sfdp/sparse-matrix.js';
+/**
+ * Proximity graph: symmetrized Delaunay adjacency (unit weights, with
+ * diagonal). @see lib/neatogen/call_tri.c:call_tri
+ */
+export declare function callTri(n: number, x: number[]): SpMatrix;
+/**
+ * The full PRISM overlap-removal loop (ELSCHEME_NONE path).
+ * @see lib/neatogen/overlap.c:remove_overlap
+ */
+export declare function removeOverlapPrism(dim: number, A: SpMatrix, x: number[], labelSizes: number[] | null, ntry: number, initialScaling: number, doShrinking: boolean): void;
+//# sourceMappingURL=overlap-prism.d.ts.map

package/dist/layout/neato/overlap-prism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap-prism.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/overlap-prism.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAsBzD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,QAAQ,CAuBxD;AAyYD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,EAClE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,GACzD,IAAI,CAoCN"}

package/dist/layout/neato/overlap.d.ts

@@ -0,0 +1,85 @@
+/**
+ * VPSC-based overlap removal for the neato layout engine.
+ *
+ * Two independent VPSC passes (X then Y) ensure that no two node bounding
+ * boxes intersect after the call returns. Each pass builds its own Variables,
+ * Rectangles, and Constraints; none are shared between passes.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ * @see lib/vpsc/csolve_VPSC.h
+ */
+import type { Node } from '../../model/node.js';
+import { type Variable, type Constraint, VPSC, Rectangle } from '../../vpsc/index.js';
+/**
+ * Builds one Rectangle per node centred on pos[], expanding each half-size
+ * by sep/2 so the VPSC gap `(w_i+w_j)/2` incorporates the padding.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ */
+export declare function buildRectangles(nodes: Node[], sep: {
+    x: number;
+    y: number;
+}): Rectangle[];
+/**
+ * Allocates one Variable per node for a single VPSC axis pass.
+ *
+ * @see lib/vpsc/csolve_VPSC.h:newVariable
+ */
+export declare function allocateVariables(nodes: Node[], axis: 0 | 1): Variable[];
+/**
+ * Writes solved positions back into node.info.pos[axis].
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust (position write-back loop)
+ */
+export declare function writePositions(nodes: Node[], vars: Variable[], axis: 0 | 1): void;
+/**
+ * Tears down a VPSC pass in mandatory order (AD-4):
+ * deleteVPSC → deleteConstraints → deleteVariable per variable.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust teardown sequence
+ */
+export declare function teardownPass(vpsc: VPSC, constraints: Constraint[], vars: Variable[]): void;
+/**
+ * Runs one complete VPSC axis pass: solve constraints then write positions.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ */
+export declare function runAxisPass(nodes: Node[], sep: {
+    x: number;
+    y: number;
+}, constraints: Constraint[], vars: Variable[], axis: 0 | 1): void;
+/**
+ * One full VPSC pass on the X axis.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust (X pass section)
+ */
+export declare function runXPass(nodes: Node[], sep: {
+    x: number;
+    y: number;
+}): void;
+/**
+ * One full VPSC pass on the Y axis.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust (Y pass section)
+ */
+export declare function runYPass(nodes: Node[], sep: {
+    x: number;
+    y: number;
+}): void;
+/**
+ * Removes overlaps between nodes using two independent VPSC passes (X then Y).
+ *
+ * After this call no two node bounding boxes intersect (with sep padding).
+ * Positions are written into node.info.pos[0] (X) and node.info.pos[1] (Y).
+ *
+ * @param nodes - Nodes with info.pos, info.width, info.height set.
+ * @param sep   - Minimum padding added beyond each node's half-size per axis.
+ *
+ * @see lib/neatogen/adjust.c:vpscAdjust
+ * @see lib/vpsc/csolve_VPSC.h
+ */
+export declare function removeOverlap(nodes: Node[], sep: {
+    x: number;
+    y: number;
+}): void;
+//# sourceMappingURL=overlap.d.ts.map

package/dist/layout/neato/overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/overlap.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAQL,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,IAAI,EACJ,SAAS,EACV,MAAM,qBAAqB,CAAC;AAE7B;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,SAAS,EAAE,CAQb;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,QAAQ,EAAE,CAExE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,IAAI,EAAE,EACb,IAAI,EAAE,QAAQ,EAAE,EAChB,IAAI,EAAE,CAAC,GAAG,CAAC,GACV,IAAI,CAON;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,IAAI,EACV,WAAW,EAAE,UAAU,EAAE,EACzB,IAAI,EAAE,QAAQ,EAAE,GACf,IAAI,CAIN;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7B,WAAW,EAAE,UAAU,EAAE,EACzB,IAAI,EAAE,QAAQ,EAAE,EAChB,IAAI,EAAE,CAAC,GAAG,CAAC,GACV,IAAI,CAKN;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAKN;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAKN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,IAAI,EAAE,EACb,GAAG,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,IAAI,CAIN"}

package/dist/layout/neato/sc-adjust.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Scale-based overlap removal — scAdjust and the adjustNodes overlap-mode
+ * subset that reaches it.
+ *
+ * `overlap=scale` (AM_NSCALE) scales the layout uniformly so node boxes stop
+ * overlapping; `scalexy` (AM_SCALEXY) scales x and y independently;
+ * `compress` (AM_COMPRESS) scales down to remove excess space. Based on
+ * Marriott, Stuckey, Tam and He, "Removing Node Overlapping in Graph Layout
+ * Using Constrained Optimization", Constraints 8(2):143-172, 2003 (per the
+ * C source comment).
+ *
+ * Other overlap modes (voronoi, prism, vpsc, ortho*) remain unported; with
+ * the attr unset C's getAdjustMode resolves to AM_NONE and the pass is a
+ * no-op (normalize/simpleScale only fire on rare attrs, also unported).
+ *
+ * @see lib/neatogen/constraint.c:scAdjust
+ * @see lib/neatogen/adjust.c:removeOverlapWith / getAdjustMode
+ */
+import type { Graph } from '../../model/graph.js';
+/**
+ * Scale the layout (positions in ND_pos INCHES).
+ * equal > 0 → uniform scale to remove overlaps; equal = 0 → separate x/y;
+ * equal < 0 → scale DOWN to remove excess space (assumes no overlaps).
+ * @see lib/neatogen/constraint.c:767 scAdjust
+ */
+export declare function scAdjust(g: Graph, equal: number): number;
+/**
+ * The adjustNodes overlap-mode subset reaching scAdjust; other modes are
+ * no-ops (see module doc).
+ * @see lib/neatogen/adjust.c:999 adjustNodes, :776 adjustMode table
+ */
+export declare function adjustNodesScale(g: Graph): number;
+//# sourceMappingURL=sc-adjust.d.ts.map

package/dist/layout/neato/sc-adjust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sc-adjust.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/sc-adjust.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAsHlD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CA8CxD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAOjD"}

package/dist/layout/neato/sep-factor.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Node/edge separation factors — expand_t, parseFactor, sepFactor,
+ * esepFactor from neatogen's adjust.c.
+ *
+ * @see lib/neatogen/adjust.c (15.0.0)
+ * @see lib/neatogen/adjust.h (15.0.0)
+ */
+import type { Graph } from '../../model/graph.js';
+/** @see lib/neatogen/adjust.h:expand_t */
+export interface ExpandT {
+    x: number;
+    y: number;
+    /** Margins are absolute additions (points) rather than scale factors. */
+    doAdd: boolean;
+}
+/** Default esep/sep ratio. @see lib/neatogen/adjust.c:SEPFACT */
+export declare const SEPFACT = 0.8;
+/** Default margin in points. @see lib/neatogen/adjust.h:DFLT_MARGIN */
+export declare const DFLT_MARGIN = 4;
+/**
+ * Convert a "sep" attribute string into an ExpandT.
+ * "+x,y" becomes {x, y, doAdd:true}; "x,y" becomes
+ * {1 + x/sepfact, 1 + y/sepfact, doAdd:false}.
+ * Returns null on parse failure (C returns 0).
+ *
+ * @see lib/neatogen/adjust.c:parseFactor
+ */
+export declare function parseFactor(s: string, sepfact: number, dflt: number): ExpandT | null;
+/**
+ * Node separation for overlap adjustment: "sep" attr, then "esep"
+ * scaled by 1/SEPFACT, then +4pt.
+ * @see lib/neatogen/adjust.c:sepFactor
+ */
+export declare function sepFactor(g: Graph): ExpandT;
+/**
+ * Edge separation for spline routing: smaller than sepFactor so the
+ * spline code does not see overlaps the adjust pass left tight.
+ * @see lib/neatogen/adjust.c:esepFactor
+ */
+export declare function esepFactor(g: Graph): ExpandT;
+//# sourceMappingURL=sep-factor.d.ts.map

package/dist/layout/neato/sep-factor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sep-factor.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/sep-factor.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAGlD,0CAA0C;AAC1C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,iEAAiE;AACjE,eAAO,MAAM,OAAO,MAAM,CAAC;AAC3B,uEAAuE;AACvE,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,GAAG,IAAI,CAYhB;AA+BD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAY3C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAY5C"}

package/dist/layout/neato/set-aspect.d.ts

@@ -0,0 +1,33 @@
+/**
+ * neato-family aspect-ratio handling — _neato_set_aspect and its helpers.
+ *
+ * C's graph_init parses ratio/size into GD_drawing for every engine; the
+ * spline_edges0(g, true) entry then reshapes the layout via neato_set_aspect
+ * before routing: fill/expand/value scale ND_pos (and the bb), compress and
+ * auto only normalize the origin. The dot engine has its own setAspect and
+ * never reaches this path.
+ *
+ * @see lib/neatogen/neatosplines.c:1023 _neato_set_aspect
+ * @see lib/neatogen/neatosplines.c:992 neato_translate
+ * @see lib/common/input.c (setRatio / graph_init)
+ */
+import type { Graph } from '../../model/graph.js';
+/**
+ * Populate g.info.drawing with the ratio/size fields _neato_set_aspect reads,
+ * mirroring graph_init's engine-neutral parse. No-op when the dot-side init
+ * already parsed a drawing.
+ */
+export declare function parseNeatoDrawing(g: Graph): void;
+/**
+ * Translate the drawing so bb.LL is the origin: node pos (inches) and
+ * xlabels, routed splines, then the bb tree.
+ * @see lib/neatogen/neatosplines.c:992 neato_translate
+ */
+export declare function neatoTranslate(g: Graph): void;
+/**
+ * Reshape the layout per ratio/size — assumes bb is computed and applies only
+ * on the root graph. Returns true when node positions moved.
+ * @see lib/neatogen/neatosplines.c:1023 _neato_set_aspect
+ */
+export declare function neatoSetAspectRatio(g: Graph): boolean;
+//# sourceMappingURL=set-aspect.d.ts.map

package/dist/layout/neato/set-aspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-aspect.d.ts","sourceRoot":"","sources":["../../../src/layout/neato/set-aspect.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAkClD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAUhD;AAwBD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAmB7C;AAoCD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO,CAuBrD"}