@knowvah/dot-engine 0.1.0

package/dist/cdt/bag.d.ts

@@ -0,0 +1,58 @@
+/**
+ * DtBag — ordered multiset (Dtobag) backed by a splay tree.
+ *
+ * Unlike DtSplay (DT_OSET), DtBag allows duplicate keys.  On insert of a
+ * duplicate, the new node is inserted immediately to the LEFT of the
+ * matching node (mirrors C dttree.c DT_OBAG insert: new node placed in
+ * link.left, i.e. the right partition, becoming the successor of the
+ * matching group — faithfully ported from dttree.c lines 226-230).
+ *
+ * Iteration (first/next) produces ascending comparator order.  Among
+ * equal-key nodes the sub-order is the deterministic order CDT's Dtobag
+ * produces (via bagInsert's integrated splay+insert) — load-bearing for the
+ * xlabel R-tree, which drains this bag to seed its Hilbert insertion order.
+ *
+ * AD4 extension: required by xlabels.ts which uses dtopen(&Hdisc, Dtobag).
+ *
+ * @see lib/cdt/dttree.c (DT_OBAG)
+ */
+import type { Comparator, KeyOf } from "./types.js";
+export declare class DtBag<T, K = T> {
+    private _root;
+    private _size;
+    private readonly _keyOf;
+    private readonly _compare;
+    constructor(keyOf: KeyOf<T, K>, compare: Comparator<K>);
+    /** @see lib/cdt/dtsize.c:dtsize */
+    size(): number;
+    /**
+     * Insert obj.  Duplicates ARE inserted (DT_OBAG semantics).
+     * @see lib/cdt/dttree.c:dttree DT_INSERT (DT_OBAG branch)
+     */
+    insert(obj: T): T;
+    /**
+     * Delete one occurrence of obj by object identity.
+     * @see lib/cdt/dttree.c:dttree DT_OBAG DT_DELETE
+     */
+    delete(obj: T): boolean;
+    /**
+     * Return the minimum element (splays to root).
+     * @see lib/cdt/dttree.c:dttree DT_FIRST
+     */
+    first(): T | undefined;
+    /**
+     * Return the in-order successor of obj.
+     * @see lib/cdt/dttree.c:dttree DT_NEXT
+     */
+    next(obj: T): T | undefined;
+    /**
+     * Return the maximum element (splays to root).
+     * @see lib/cdt/dttree.c:dttree DT_LAST
+     */
+    last(): T | undefined;
+    /** Remove all elements. */
+    clear(): void;
+    /** Iterate in ascending comparator order via first() / next(). */
+    [Symbol.iterator](): Iterator<T>;
+}
+//# sourceMappingURL=bag.d.ts.map

package/dist/cdt/bag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bag.d.ts","sourceRoot":"","sources":["../../src/cdt/bag.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAgEpD,qBAAa,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC;IACzB,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAE7B,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;IAKtD,mCAAmC;IACnC,IAAI,IAAI,MAAM;IAEd;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAcjB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAevB;;;OAGG;IACH,KAAK,IAAI,CAAC,GAAG,SAAS;IAMtB;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAe3B;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS;IAMrB,2BAA2B;IAC3B,KAAK,IAAI,IAAI;IAKb,kEAAkE;IAClE,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;CAcjC"}

package/dist/cdt/hash-core.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Internal types and resize helpers for DtHash.
+ *
+ * Ported from lib/cdt/dthash.c (Kiem-Phong Vo, 05/25/96) and
+ * lib/cdt/dthdr.h macros: HSLOT, HRESIZE, HLOAD, HINDEX.
+ *
+ * @see lib/cdt/dthash.c:dthtab
+ * @see lib/cdt/dthdr.h
+ */
+/** Initial number of hash slots — HSLOT from dthdr.h */
+export declare const HSLOT = 256;
+/** Load threshold: resize when size > HLOAD(ntab) = 2*ntab @see dthdr.h:HLOAD */
+export declare function hload(n: number): number;
+/** Map hash to slot index: HINDEX(n,h) = h & (n-1) @see dthdr.h:HINDEX */
+export declare function hindex(n: number, h: number): number;
+/** Internal chain node — analogous to Dtlink_t used in DT_SET mode. */
+export interface HashNode<T> {
+    right: HashNode<T> | null;
+    hash: number;
+    obj: T;
+}
+/**
+ * Migrate one slot's chain into newSlots of size n.
+ * Nodes that map to a different slot are moved; those that stay are left
+ * in oldSlots[si] and copied to newSlots[si] at the end.
+ * @see lib/cdt/dthash.c:dthtab (inner rehash loop)
+ */
+export declare function migrateChain<T>(oldSlots: Array<HashNode<T> | null>, newSlots: Array<HashNode<T> | null>, si: number, n: number): void;
+/**
+ * Compute the smallest power-of-two slot count that keeps size under load.
+ * @see lib/cdt/dthash.c:dthtab (size computation block)
+ */
+export declare function targetSlotCount(current: number, size: number): number;
+/**
+ * Resize and rehash the table; returns the new slot array.
+ * No-op (returns oldSlots unchanged) when no resize is needed.
+ * @see lib/cdt/dthash.c:dthtab
+ */
+export declare function rehash<T>(oldSlots: Array<HashNode<T> | null>, size: number): Array<HashNode<T> | null>;
+//# sourceMappingURL=hash-core.d.ts.map

package/dist/cdt/hash-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-core.d.ts","sourceRoot":"","sources":["../../src/cdt/hash-core.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;AAEH,wDAAwD;AACxD,eAAO,MAAM,KAAK,MAAM,CAAC;AAEzB,iFAAiF;AACjF,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAmB;AAE3D,0EAA0E;AAC1E,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAwB;AAE5E,uEAAuE;AACvE,MAAM,WAAW,QAAQ,CAAC,CAAC;IACzB,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAG,MAAM,CAAC;IACd,GAAG,EAAI,CAAC,CAAC;CACV;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACnC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACnC,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,GACR,IAAI,CAiBN;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,CAAC,EACtB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,EACnC,IAAI,EAAE,MAAM,GACX,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAQ3B"}

package/dist/cdt/hash.d.ts

@@ -0,0 +1,74 @@
+/**
+ * DtHash — unordered set (DT_SET) backed by a separate-chaining hash table.
+ *
+ * Ported faithfully from lib/cdt/dthash.c (Kiem-Phong Vo, 05/25/96).
+ *
+ * Behavioral contracts preserved from C:
+ *  - Initial slot count: 256 (HSLOT)
+ *  - Resize when size > 2*ntab, suppressed while loop > 0
+ *  - loop counter: first() increments; next() returning undefined decrements
+ *  - Move-to-front on search when loop === 0; suppressed during walk
+ *
+ * @see lib/cdt/dthash.c
+ * @see lib/cdt/dthdr.h
+ */
+import type { Comparator, KeyOf } from "./types.js";
+/**
+ * DtHash — unordered set backed by a separate-chaining hash table.
+ * @see lib/cdt/dthash.c:dthash
+ */
+export declare class DtHash<T, K = T> {
+    private _slots;
+    private _size;
+    /** Nesting depth of active walks — suppresses resize when > 0. */
+    private _loop;
+    /** Finger: last accessed node — analogous to dt->data.here */
+    private _here;
+    private readonly _keyOf;
+    private readonly _hash;
+    private readonly _compare;
+    constructor(keyOf: KeyOf<T, K>, hash: (key: K) => number, compare: Comparator<K>);
+    /** @see lib/cdt/dtsize.c:dtsize */
+    size(): number;
+    /** Allocate the slot array on first use. */
+    private _ensureSlots;
+    /**
+     * Find a node by key.
+     * Returns [node, predecessor, slotIndex]; node is null when not found.
+     */
+    private _find;
+    /** Resize if over load and no active walk. */
+    private _maybeResize;
+    /** End an active walk: decrement loop, possibly trigger deferred resize. */
+    private _endWalk;
+    /**
+     * Insert obj.  If key already exists returns the existing object (DT_SET).
+     * @see lib/cdt/dthash.c:dthash DT_INSERT
+     */
+    insert(obj: T): T;
+    /**
+     * Delete obj by key.  Returns true if found and removed.
+     * @see lib/cdt/dthash.c:dthash DT_DELETE
+     */
+    delete(obj: T): boolean;
+    /**
+     * Search by key.  Applies move-to-front when loop === 0.
+     * @see lib/cdt/dthash.c:dthash DT_SEARCH
+     */
+    search(key: K): T | undefined;
+    /**
+     * Return the first element; increments the walk loop counter.
+     * Scans slots from index 0 upward.
+     * @see lib/cdt/dthash.c:dthash DT_FIRST
+     */
+    first(): T | undefined;
+    /**
+     * Return the next element; advance within chain then across slots.
+     * Decrements loop counter and triggers deferred resize when exhausted.
+     * @see lib/cdt/dthash.c:dthash DT_NEXT
+     */
+    next(_obj: T): T | undefined;
+    /** Remove all elements. @see lib/cdt/dthash.c:dthash DT_CLEAR */
+    clear(): void;
+}
+//# sourceMappingURL=hash.d.ts.map

package/dist/cdt/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/cdt/hash.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AASpD;;;GAGG;AACH,qBAAa,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC;IAC1B,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,KAAK,CAAM;IACnB,kEAAkE;IAClE,OAAO,CAAC,KAAK,CAAM;IACnB,8DAA8D;IAC9D,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAGvC,KAAK,EAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,EAAK,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,EAC3B,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;IAOxB,mCAAmC;IACnC,IAAI,IAAI,MAAM;IAId,4CAA4C;IAC5C,OAAO,CAAC,YAAY;IAMpB;;;OAGG;IACH,OAAO,CAAC,KAAK;IAeb,8CAA8C;IAC9C,OAAO,CAAC,YAAY;IAOpB,4EAA4E;IAC5E,OAAO,CAAC,QAAQ;IAUhB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAuBjB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAcvB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAe7B;;;;OAIG;IACH,KAAK,IAAI,CAAC,GAAG,SAAS;IAWtB;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAc5B,iEAAiE;IACjE,KAAK,IAAI,IAAI;CAMd"}

package/dist/cdt/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * lib/cdt — Container Data Types public API.
+ *
+ * Exports DtSplay (DT_OSET), DtHash (DT_SET), and dtStrHash.
+ *
+ * @see lib/cdt/cdt.h
+ * @see lib/cdt/dttree.c
+ * @see lib/cdt/dthash.c
+ * @see lib/cdt/dtstrhash.c
+ */
+export type { Comparator, KeyOf } from "./types.js";
+export { DtSplay } from "./splay.js";
+export { DtBag } from "./bag.js";
+export { DtHash } from "./hash.js";
+export { dtStrHash } from "./strhash.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cdt/index.ts"],"names":[],"mappings":"AACA;;;;;;;;;GASG;AAEH,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,OAAO,EAAE,KAAK,EAAE,MAAQ,UAAU,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAO,WAAW,CAAC;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/cdt/splay-core.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Internal splay-tree node type and top-down splay algorithm.
+ *
+ * Ported faithfully from lib/cdt/dttree.c (Kiem-Phong Vo, 5/25/96)
+ * and lib/cdt/dthdr.h.
+ *
+ * PARTITION NAMING INVERSION (preserved from C source):
+ *   The dummy `link` node uses inverted field names:
+ *     link.right  → head of the LEFT  partition (keys < target)
+ *     link.left   → head of the RIGHT partition (keys > target)
+ *   `l` is the tail pointer into link.right (LEFT partition).
+ *   `r` is the tail pointer into link.left  (RIGHT partition).
+ *   llink(l, x): l = l.right = x   — extends LEFT  partition
+ *   rlink(r, x): r = r.left  = x   — extends RIGHT partition
+ *
+ * @see lib/cdt/dttree.c
+ * @see lib/cdt/dthdr.h
+ */
+import type { Comparator, KeyOf } from "./types.js";
+/** Internal tree node — analogous to Dtlink_t in the C source. */
+export interface SplayNode<T> {
+    left: SplayNode<T> | null;
+    right: SplayNode<T> | null;
+    obj: T;
+}
+export declare function rrotate<T>(x: SplayNode<T>, y: SplayNode<T>): void;
+export declare function lrotate<T>(x: SplayNode<T>, y: SplayNode<T>): void;
+/**
+ * Splay minimum of `subtree` to its root via repeated RROTATE.
+ * Returns the new root (which has no left child).
+ * Mirrors the DT_FIRST loop and the DT_NEXT subtree-min logic.
+ * @see lib/cdt/dttree.c:dttree DT_FIRST / DT_NEXT
+ */
+export declare function splayMin<T>(subtree: SplayNode<T>): SplayNode<T>;
+/**
+ * Splay maximum of `subtree` to its root via repeated LROTATE.
+ * Returns the new root (which has no right child).
+ * Mirrors the DT_LAST loop and the DT_PREV subtree-max logic.
+ * @see lib/cdt/dttree.c:dttree DT_LAST / DT_PREV
+ */
+export declare function splayMax<T>(subtree: SplayNode<T>): SplayNode<T>;
+/**
+ * Insert `node` as new root by splitting `oldRoot` at the given comparison
+ * result `cmp` (compare(newKey, oldRoot.key)).
+ * `cmp` must be non-zero (caller already checked for duplicate).
+ * Returns the new root.
+ * @see lib/cdt/dttree.c:dttree DT_INSERT (not-found branch)
+ */
+export declare function splaySplitInsert<T>(node: SplayNode<T>, oldRoot: SplayNode<T>, cmp: number): SplayNode<T>;
+/**
+ * Integrated top-down splay + insert, faithfully mirroring CDT's
+ * `dttree.c` DT_INSERT for a Dtobag (duplicate keys allowed).
+ *
+ * This differs from `splay()` + a separate splice: CDT inserts the new node
+ * *while the tree is still partitioned* into the LEFT (keys < target) and
+ * RIGHT (keys > target) spine-trees, pushing the found equal-key node onto
+ * the head of the RIGHT partition before the new node becomes root. Splaying
+ * to reassemble a normal BST first and only then splicing produces a
+ * different equal-key sub-order — which is load-bearing for the xlabel R-tree
+ * (its Hilbert-bag drain order, and therefore the tree it builds, depends on
+ * the exact duplicate ordering; see label/xlabels.ts).
+ *
+ * The do-search loop is identical to `splay()`; only the terminal insert
+ * differs. Returns the new root (always `node`).
+ *
+ * @see lib/cdt/dttree.c:dttree DT_INSERT (do_search + DT_OBAG found/has_root)
+ */
+export declare function bagInsert<T, K>(root: SplayNode<T>, node: SplayNode<T>, keyOf: KeyOf<T, K>, compare: Comparator<K>): SplayNode<T>;
+/**
+ * Top-down splay.
+ *
+ * Splays the node whose key equals `key` (or the closest node) to root.
+ * Returns the new root.  Always performs structural mutations.
+ *
+ * @see lib/cdt/dttree.c:dttree (do_search loop)
+ */
+export declare function splay<T, K>(root: SplayNode<T>, key: K, keyOf: KeyOf<T, K>, compare: Comparator<K>): SplayNode<T>;
+//# sourceMappingURL=splay-core.d.ts.map

package/dist/cdt/splay-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splay-core.d.ts","sourceRoot":"","sources":["../../src/cdt/splay-core.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEpD,kEAAkE;AAClE,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC1B,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC3B,GAAG,EAAE,CAAC,CAAC;CACR;AAMD,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAGjE;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAGjE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAQ/D;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAQ/D;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAClB,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EACrB,GAAG,EAAE,MAAM,GACV,SAAS,CAAC,CAAC,CAAC,CAad;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAClB,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAClB,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,SAAS,CAAC,CAAC,CAAC,CAiDd;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EACxB,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,EAClB,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACrB,SAAS,CAAC,CAAC,CAAC,CAgHd"}

package/dist/cdt/splay.d.ts

@@ -0,0 +1,63 @@
+/**
+ * DtSplay — ordered set (DT_OSET) backed by a top-down splay tree.
+ *
+ * Iteration order: ascending by comparator (same as DT_OSET in the C source).
+ * Every operation is a structural mutation (splay rotation) — intentional.
+ *
+ * @see lib/cdt/dttree.c
+ */
+import type { Comparator, KeyOf } from "./types.js";
+export declare class DtSplay<T, K = T> {
+    /** Current root — analogous to dt->data.here in the C source. */
+    private _root;
+    private _size;
+    private readonly _keyOf;
+    private readonly _compare;
+    constructor(keyOf: KeyOf<T, K>, compare: Comparator<K>);
+    /** @see lib/cdt/dtsize.c:dtsize */
+    size(): number;
+    /**
+     * Insert obj.  If the key already exists returns the existing object
+     * unchanged (DT_OSET: no duplicates).
+     * @see lib/cdt/dttree.c:dttree DT_INSERT
+     */
+    insert(obj: T): T;
+    /**
+     * Delete obj by key.  Returns true if found and removed.
+     * @see lib/cdt/dttree.c:dttree DT_DELETE
+     */
+    delete(obj: T): boolean;
+    /**
+     * Search by key.  Splays found node to root.
+     * @see lib/cdt/dttree.c:dttree DT_SEARCH
+     */
+    search(key: K): T | undefined;
+    /**
+     * Return the minimum element; splays it to root.
+     * @see lib/cdt/dttree.c:dttree DT_FIRST
+     */
+    first(): T | undefined;
+    /**
+     * Return the in-order successor of obj.
+     * @see lib/cdt/dttree.c:dttree DT_NEXT
+     */
+    next(obj: T): T | undefined;
+    /**
+     * Return the maximum element; splays it to root.
+     * @see lib/cdt/dttree.c:dttree DT_LAST
+     */
+    last(): T | undefined;
+    /**
+     * Return the in-order predecessor of obj.
+     * @see lib/cdt/dttree.c:dttree DT_PREV
+     */
+    prev(obj: T): T | undefined;
+    /** Remove all elements. @see lib/cdt/dttree.c:dttree DT_CLEAR */
+    clear(): void;
+    /**
+     * Iterate in ascending comparator order via first() / next().
+     * Each step is a structural mutation per C DT_OSET spec.
+     */
+    [Symbol.iterator](): Iterator<T>;
+}
+//# sourceMappingURL=splay.d.ts.map

package/dist/cdt/splay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splay.d.ts","sourceRoot":"","sources":["../../src/cdt/splay.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAWpD,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC;IAC3B,iEAAiE;IACjE,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;gBAE7B,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;IAKtD,mCAAmC;IACnC,IAAI,IAAI,MAAM;IAEd;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC;IAmBjB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAqBvB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAO7B;;;OAGG;IACH,KAAK,IAAI,CAAC,GAAG,SAAS;IAMtB;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAqB3B;;;OAGG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS;IAMrB;;;OAGG;IACH,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAqB3B,iEAAiE;IACjE,KAAK,IAAI,IAAI;IAKb;;;OAGG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC;CAcjC"}

package/dist/cdt/strhash.d.ts

@@ -0,0 +1,26 @@
+/**
+ * dtStrHash — polynomial rolling hash for null-terminated strings.
+ *
+ * Exact port of dtstrhash() from lib/cdt/dtstrhash.c (Kiem-Phong Vo, 02/28/03).
+ *
+ * Algorithm (n <= 0 / string mode):
+ *   Advance 2 bytes per step; if the second byte is \0, advance only 1.
+ *   h = (h + (s[0] << 8) + s[1]) * DT_PRIME  at each step.
+ *   Add string length at the end: (h + n) * DT_PRIME.
+ *
+ * The unusual 2-byte stepping with the \0 guard is a micro-optimisation in
+ * the original C and must be preserved exactly to produce matching hash values.
+ *
+ * @see lib/cdt/dtstrhash.c:dtstrhash
+ */
+/**
+ * Hash a JavaScript string using the dtstrhash algorithm (n <= 0 / string mode).
+ *
+ * TypeScript strings are UTF-16; we operate on char codes directly to match
+ * the C behaviour of treating each character as one byte (ASCII / Latin-1).
+ * Callers using non-ASCII keys must ensure their comparator is consistent.
+ *
+ * @see lib/cdt/dtstrhash.c:dtstrhash
+ */
+export declare function dtStrHash(s: string): number;
+//# sourceMappingURL=strhash.d.ts.map

package/dist/cdt/strhash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strhash.d.ts","sourceRoot":"","sources":["../../src/cdt/strhash.ts"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;GAcG;AAWH;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB3C"}

package/dist/cdt/types.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared type definitions for lib/cdt.
+ * Kept in a leaf module to avoid circular imports.
+ *
+ * @see lib/cdt/cdt.h
+ */
+/** Key comparator: returns negative, zero, or positive. @see Dtcompar_f */
+export type Comparator<K> = (a: K, b: K) => number;
+/** Extract the key from an object. @see Dtdisc_t */
+export type KeyOf<T, K> = (obj: T) => K;
+//# sourceMappingURL=types.d.ts.map

package/dist/cdt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/cdt/types.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAEnD,oDAAoD;AACpD,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC"}

package/dist/common/arith.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Arithmetic primitives shared with the C reference build.
+ *
+ * @see lib/common/arith.h
+ */
+/**
+ * C rounding: round half **away from zero**.
+ *
+ * This is the single shared implementation of the one rounding deviation that
+ * separates this port from C. Both C spellings agree on it:
+ *
+ * - libm `round()` — "rounding halfway cases away from zero" (C99 7.12.9.6),
+ *   used directly across `lib/` (e.g. `lib/dotgen/compound.c:41`,
+ *   `lib/pack/pack.c:435`, `lib/dotgen/position.c:966`).
+ * - the `ROUND` macro — `((f>=0)?(int)(f + .5):(int)(f - .5))`
+ *   (`lib/common/arith.h:48`), whose truncating casts also break ties away
+ *   from zero. `POINTS(a_inches)` (`lib/common/geom.h:62`) is `ROUND` too.
+ *
+ * JavaScript's `Math.round` breaks ties toward +∞ (`Math.round(-4.5) === -4`,
+ * C `round(-4.5) === -5`), so it diverges by 1 on **every exact negative
+ * half-integer**. Layout coordinates are routinely negative (center-origin
+ * engines, cluster walls left of an endpoint, port offsets from a node centre)
+ * and are often exact integers or halves, so such ties are ordinary, not
+ * exotic.
+ *
+ * Use this for every site that mirrors a C `round()`/`ROUND()`/`POINTS()`,
+ * including sites whose argument happens to be non-negative today — it costs
+ * nothing and states the intent. Do **not** use it where C rounds by some
+ * other rule (`(int)` truncation, `floor`, printf `%.0f` banker's rounding).
+ *
+ * @see lib/common/arith.h:48 (ROUND)
+ * @see C99 7.12.9.6 (round)
+ */
+export declare function cround(v: number): number;
+//# sourceMappingURL=arith.d.ts.map

package/dist/common/arith.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arith.d.ts","sourceRoot":"","sources":["../../src/common/arith.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAExC"}

package/dist/common/arm-pow-data.d.ts

@@ -0,0 +1,17 @@
+/** ln2 high/low split. */
+export declare const ARM_LN2HI: number[];
+export declare const ARM_LN2LO: number[];
+/** Log polynomial coefficients A[0..6] (pre-scaled). */
+export declare const ARM_LOG_POLY: number[];
+/** Log table: 128 × (invc, logc, logctail) bit patterns. */
+export declare const ARM_LOG_TAB: number[];
+/** Exp argument-reduction constants. */
+export declare const ARM_INVLN2N: number[];
+export declare const ARM_SHIFT: number[];
+export declare const ARM_NEGLN2HIN: number[];
+export declare const ARM_NEGLN2LON: number[];
+/** Exp polynomial coefficients (poly[0..5]). */
+export declare const ARM_EXP_POLY: number[];
+/** Exp table: 256 uint64 entries (tail/sbits pairs) as [hi32, lo32]. */
+export declare const ARM_EXP_TAB: number[];
+//# sourceMappingURL=arm-pow-data.d.ts.map

package/dist/common/arm-pow-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arm-pow-data.d.ts","sourceRoot":"","sources":["../../src/common/arm-pow-data.ts"],"names":[],"mappings":"AAYA,0BAA0B;AAC1B,eAAO,MAAM,SAAS,UAA2B,CAAC;AAClD,eAAO,MAAM,SAAS,UAA2B,CAAC;AAElD,wDAAwD;AACxD,eAAO,MAAM,YAAY,EAAE,MAAM,EAGhC,CAAC;AAEF,4DAA4D;AAC5D,eAAO,MAAM,WAAW,EAAE,MAAM,EAiG/B,CAAC;AAEF,wCAAwC;AACxC,eAAO,MAAM,WAAW,UAA2B,CAAC;AACpD,eAAO,MAAM,SAAS,UAA2B,CAAC;AAClD,eAAO,MAAM,aAAa,UAA2B,CAAC;AACtD,eAAO,MAAM,aAAa,UAA2B,CAAC;AAEtD,gDAAgD;AAChD,eAAO,MAAM,YAAY,EAAE,MAAM,EAGhC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,WAAW,EAAE,MAAM,EAiE/B,CAAC"}

package/dist/common/arm-pow.d.ts

@@ -0,0 +1,12 @@
+/**
+ * pow(x, y). The normal-finite fast path is the log_inline/exp_inline core;
+ * the special-case branch (x or y is 0/inf/nan, negative base, subnormal base,
+ * or extreme |y|) is ported faithfully so armPow returns exactly what libm's
+ * pow returns — including `pow(NaN, y) = NaN`. This matters for sfdp graphs
+ * whose force loop blows up to NaN under a large `repulsiveforce` (e.g. 2556,
+ * repulsiveforce=100 → the native oracle itself emits all-`nan` positions):
+ * the port must reproduce the same NaN, not throw.
+ * @see ARM optimized-routines math/pow.c:pow
+ */
+export declare function armPow(x: number, y: number): number;
+//# sourceMappingURL=arm-pow.d.ts.map

package/dist/common/arm-pow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arm-pow.d.ts","sourceRoot":"","sources":["../../src/common/arm-pow.ts"],"names":[],"mappings":"AAuOA;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsDnD"}

package/dist/common/arrows-constants.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Arrow type and modifier constants, name/type tables ported from
+ * lib/common/arrows.c internal definitions.
+ *
+ * @see lib/common/arrows.c
+ */
+/** @see lib/common/arrows.c:#define EPSILON */
+export declare const EPSILON = 0.0001;
+/** Standard arrow length in points. @see lib/common/arrows.c:#define ARROW_LENGTH */
+export declare const ARROW_LENGTH = 10;
+/** Number of arrow heads per flag word. @see lib/common/arrows.c:#define NUMB_OF_ARROW_HEADS */
+export declare const NUMB_OF_ARROW_HEADS = 4;
+/** Bits per arrow slot in the flag word. @see lib/common/arrows.c:#define BITS_PER_ARROW */
+export declare const BITS_PER_ARROW = 8;
+/** Bits used for the arrow type portion. @see lib/common/arrows.c:#define BITS_PER_ARROW_TYPE */
+export declare const BITS_PER_ARROW_TYPE = 4;
+/** @see lib/common/arrows.c:#define ARR_TYPE_NONE */
+export declare const ARR_TYPE_NONE = 0;
+/** @see lib/common/arrows.c:#define ARR_TYPE_NORM */
+export declare const ARR_TYPE_NORM = 1;
+/** @see lib/common/arrows.c:#define ARR_TYPE_CROW */
+export declare const ARR_TYPE_CROW = 2;
+/** @see lib/common/arrows.c:#define ARR_TYPE_TEE */
+export declare const ARR_TYPE_TEE = 3;
+/** @see lib/common/arrows.c:#define ARR_TYPE_BOX */
+export declare const ARR_TYPE_BOX = 4;
+/** @see lib/common/arrows.c:#define ARR_TYPE_DIAMOND */
+export declare const ARR_TYPE_DIAMOND = 5;
+/** @see lib/common/arrows.c:#define ARR_TYPE_DOT */
+export declare const ARR_TYPE_DOT = 6;
+/** @see lib/common/arrows.c:#define ARR_TYPE_CURVE */
+export declare const ARR_TYPE_CURVE = 7;
+/** @see lib/common/arrows.c:#define ARR_TYPE_GAP */
+export declare const ARR_TYPE_GAP = 8;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_NORM lenfact */
+export declare const ARR_LENFACT_NORM = 1;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_CROW lenfact */
+export declare const ARR_LENFACT_CROW = 1;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_TEE lenfact */
+export declare const ARR_LENFACT_TEE = 0.5;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_BOX lenfact */
+export declare const ARR_LENFACT_BOX = 1;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_DIAMOND lenfact */
+export declare const ARR_LENFACT_DIAMOND = 1.2;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_DOT lenfact */
+export declare const ARR_LENFACT_DOT = 0.8;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_CURVE lenfact */
+export declare const ARR_LENFACT_CURVE = 1;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_GAP lenfact */
+export declare const ARR_LENFACT_GAP = 0.5;
+/**
+ * Length factor indexed by ARR_TYPE_* code. ARR_TYPE_NONE (0) has no shape;
+ * it maps to 0 so a none-arrow contributes no clip length.
+ * @see lib/common/arrows.c:Arrowtypes
+ */
+export declare const ARR_LENFACT_BY_TYPE: readonly number[];
+/** Mask selecting the type-code portion (low BITS_PER_ARROW_TYPE bits). */
+export declare const ARR_TYPE_MASK: number;
+/** Open/outline only. @see lib/common/arrows.c:#define ARR_MOD_OPEN */
+export declare const ARR_MOD_OPEN: number;
+/** Inverted direction. @see lib/common/arrows.c:#define ARR_MOD_INV */
+export declare const ARR_MOD_INV: number;
+/** Left half only. @see lib/common/arrows.c:#define ARR_MOD_LEFT */
+export declare const ARR_MOD_LEFT: number;
+/** Right half only. @see lib/common/arrows.c:#define ARR_MOD_RIGHT */
+export declare const ARR_MOD_RIGHT: number;
+/** One entry in an arrow name/flag table. @see lib/common/arrows.c:arrowname_t */
+export interface ArrowNameEntry {
+    readonly name: string;
+    readonly type: number;
+}
+/**
+ * Backward-compatibility synonyms for deprecated arrow names.
+ * Evaluated before Arrownames so "invempty" resolves correctly.
+ * @see lib/common/arrows.c:Arrowsynonyms
+ */
+export declare const ARROW_SYNONYMS: readonly ArrowNameEntry[];
+/**
+ * Modifier prefix tokens.
+ * @see lib/common/arrows.c:Arrowmods
+ */
+export declare const ARROW_MODS: readonly ArrowNameEntry[];
+/**
+ * Primary arrow shape names.
+ * @see lib/common/arrows.c:Arrownames
+ */
+export declare const ARROW_NAMES_TABLE: readonly ArrowNameEntry[];
+/**
+ * Direction strings and their corresponding start/end flag values.
+ * @see lib/common/arrows.c:Arrowdirs
+ */
+export declare const ARROW_DIRS: readonly {
+    dir: string;
+    sflag: number;
+    eflag: number;
+}[];
+//# sourceMappingURL=arrows-constants.d.ts.map

package/dist/common/arrows-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-constants.d.ts","sourceRoot":"","sources":["../../src/common/arrows-constants.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAMH,+CAA+C;AAC/C,eAAO,MAAM,OAAO,SAAS,CAAC;AAE9B,qFAAqF;AACrF,eAAO,MAAM,YAAY,KAAO,CAAC;AAEjC,gGAAgG;AAChG,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,4FAA4F;AAC5F,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,iGAAiG;AACjG,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAMrC,qDAAqD;AACrD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,qDAAqD;AACrD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,qDAAqD;AACrD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,oDAAoD;AACpD,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,oDAAoD;AACpD,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,wDAAwD;AACxD,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,oDAAoD;AACpD,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,sDAAsD;AACtD,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,oDAAoD;AACpD,eAAO,MAAM,YAAY,IAAI,CAAC;AAO9B,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,IAAM,CAAC;AACpC,gEAAgE;AAChE,eAAO,MAAM,gBAAgB,IAAM,CAAC;AACpC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,IAAM,CAAC;AACnC,mEAAmE;AACnE,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,MAAM,CAAC;AACnC,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,IAAM,CAAC;AACrC,+DAA+D;AAC/D,eAAO,MAAM,eAAe,MAAM,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAY7C,CAAC;AAEL,2EAA2E;AAC3E,eAAO,MAAM,aAAa,QAAiC,CAAC;AAM5D,uEAAuE;AACvE,eAAO,MAAM,YAAY,QAAiC,CAAC;AAC3D,uEAAuE;AACvE,eAAO,MAAM,WAAW,QAAiC,CAAC;AAC1D,oEAAoE;AACpE,eAAO,MAAM,YAAY,QAAiC,CAAC;AAC3D,sEAAsE;AACtE,eAAO,MAAM,aAAa,QAAiC,CAAC;AAM5D,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,cAAc,EAEnD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,cAAc,EAM/C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAgBtD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,EAKA,CAAC"}

package/dist/common/arrows-geometry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pure geometry helpers for arrow rendering.
+ * Ported from the internal static functions in lib/common/arrows.c.
+ *
+ * @see lib/common/arrows.c
+ */
+import type { Point } from '../model/geom.js';
+/** @see lib/common/geomprocs.h:add_pointf */
+export declare function addPoint(a: Point, b: Point): Point;
+/** @see lib/common/geomprocs.h:sub_pointf */
+export declare function subPoint(a: Point, b: Point): Point;
+/** @see lib/common/geomprocs.h:scale */
+export declare function scalePoint(s: number, p: Point): Point;
+/** Euclidean distance between two points. @see lib/common/arrows.c:DIST macro */
+export declare function dist(a: Point, b: Point): number;
+/** Signed angle in radians from direction vector (dx, dy). */
+export declare function signedAngle(dx: number, dy: number): number;
+export type { Triangle } from './arrows-miter.js';
+/**
+ * Miter (or bevel fallback) line-join shape for a stroke corner at P.
+ * @see lib/common/arrows.c:miter_shape
+ */
+export declare function miterShape(baseLeft: Point, P: Point, baseRight: Point, penwidth: number): import('./arrows-miter.js').Triangle;
+//# sourceMappingURL=arrows-geometry.d.ts.map

package/dist/common/arrows-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrows-geometry.d.ts","sourceRoot":"","sources":["../../src/common/arrows-geometry.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAO9C,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAElD;AAED,6CAA6C;AAC7C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAElD;AAED,wCAAwC;AACxC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,CAErD;AAED,iFAAiF;AACjF,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,GAAG,MAAM,CAE/C;AAMD,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAI1D;AAMD,YAAY,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,QAAQ,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,GAC5D,OAAO,mBAAmB,EAAE,QAAQ,CAEtC"}

package/dist/common/arrows-miter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Miter line-join shape computation, split from arrows-geometry.ts to
+ * satisfy per-function line-length limits.
+ *
+ * @see lib/common/arrows.c:miter_shape
+ */
+import type { Point } from '../model/geom.js';
+/**
+ * Three points describing a line-join shape at a stroke corner.
+ * points[0] = miter tip P3 (or bevel midpoint)
+ * points[1] = P1 (left penwidth offset)
+ * points[2] = P2 (right penwidth offset)
+ *
+ * @see lib/common/arrows.c:triangle
+ */
+export type Triangle = {
+    readonly points: readonly [Point, Point, Point];
+};
+/**
+ * Miter (or bevel fallback) line-join shape for a stroke corner at P.
+ * @see lib/common/arrows.c:miter_shape
+ */
+export declare function miterShapeImpl(baseLeft: Point, P: Point, baseRight: Point, penwidth: number): Triangle;
+//# sourceMappingURL=arrows-miter.d.ts.map