@erd-studio/renderer 0.1.4 → 0.4.0

package/dist/types/lib/edgeRouting/render/corners.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Edge routing — how much of each segment a corner eats.
+ *
+ * Every interior vertex of a simplified polyline becomes a corner that
+ * starts `rIn` px before the vertex (along the incoming segment) and ends
+ * `rOut` px after it (along the outgoing one). Between corners, what is left
+ * of a segment is drawn straight; hops and cuts may only sit there.
+ *
+ *   sharp    0
+ *   rounded  up to 8 px, a quadratic (today's smooth-step look)
+ *   curved   up to CURVE_RADIUS px each way, an elliptical quarter (cubic).
+ *            An interior segment is shared by its two corners (half each);
+ *            the first and last segments (from the card stubs) go wholly to
+ *            their one corner, so a short step becomes one soft S. The
+ *            curve stays inside the corner's triangle, so it only ever cuts
+ *            the corner, never swings out; given the cards, a corner that
+ *            would cut into one is shrunk until it clears.
+ */
+import type { CornerMode, Point, Rect } from '../types.js';
+export declare const ROUNDED_RADIUS = 8;
+/** Largest radius of a curved corner. */
+export declare const CURVE_RADIUS = 40;
+/** Cubic control-point factor for a quarter circle (and ellipse). */
+export declare const KAPPA = 0.5523;
+export interface CornerRadii {
+    /** Length of each segment `i` (pts[i] → pts[i+1]). */
+    segLen: Float64Array;
+    /** Per vertex: px trimmed from the incoming segment (0 at the two ends). */
+    rIn: Float64Array;
+    /** Per vertex: px trimmed from the outgoing segment (0 at the two ends). */
+    rOut: Float64Array;
+}
+export declare function cornerRadii(pts: readonly Point[], mode: CornerMode, obstacles?: readonly Rect[]): CornerRadii;
+/** The corner's start / end points and cubic control points. */
+export declare function cornerCurve(prev: Point, cur: Point, next: Point, rIn: number, rOut: number): {
+    a: {
+        x: number;
+        y: number;
+    };
+    c1: {
+        x: number;
+        y: number;
+    };
+    c2: {
+        x: number;
+        y: number;
+    };
+    b: {
+        x: number;
+        y: number;
+    };
+};

package/dist/types/lib/edgeRouting/render/crossings.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Edge routing — where routed lines cross each other.
+ *
+ * Works on the simplified polylines (one segment per straight run). A
+ * crossing is *proper*: the two segments cut through each other strictly
+ * inside both of them. Touching ends, a corner sitting on another line,
+ * and collinear overlaps (a shared channel) are not crossings.
+ *
+ * A sweep over segments sorted by left edge keeps this well under a
+ * millisecond for a few hundred segments.
+ */
+import type { Point } from '../types.js';
+/** One end of a crossing: which line, which segment, how far along it (px). */
+export interface CrossingEnd {
+    line: number;
+    seg: number;
+    /** Distance from the segment's first point. */
+    d: number;
+}
+export interface Crossing {
+    x: number;
+    y: number;
+    a: CrossingEnd;
+    b: CrossingEnd;
+}
+/** Every proper crossing between segments of different lines. */
+export declare function findCrossings(polys: readonly Point[][]): Crossing[];

package/dist/types/lib/edgeRouting/render/curveCrossings.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Edge routing — where a drawn corner curve crosses another line's
+ * straight stretch.
+ *
+ * `findCrossings` works on the routed polylines, which is exact only where
+ * both lines are drawn straight. A rounded or curved corner cuts inside its
+ * vertex, so where a corner is involved the polyline crossing is in the wrong
+ * place (or the drawn lines do not cross at all, or cross where the
+ * polylines do not). With curved corners that is most crossings. This finds
+ * them on the drawn geometry: each corner curve flattened into chords,
+ * against every other line's straight stretches (the part of each segment no
+ * corner eats).
+ *
+ * Curve against curve is left out: there is no straight line to break.
+ */
+import type { CornerMode, Point } from '../types.js';
+import { type CornerRadii } from './corners.js';
+import type { CrossingEnd } from './crossings.js';
+export interface CurveCrossing {
+    x: number;
+    y: number;
+    /** The straight line's end, as `findCrossings` reports it (distance from the segment's first point). */
+    straight: CrossingEnd;
+    /** The curving line, its corner vertex, and how far through the corner (0..1). */
+    curve: {
+        line: number;
+        vertex: number;
+        t: number;
+    };
+}
+/**
+ * Every crossing between one line's corner curve and another line's straight
+ * stretch. `radii[i]` must be the radii the paths are drawn with.
+ */
+export declare function findCurveCrossings(polys: readonly Point[][], radii: readonly CornerRadii[], mode: CornerMode): CurveCrossing[];

package/dist/types/lib/edgeRouting/render/pathRender.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Edge routing — turn routed polylines into SVG paths.
+ *
+ * Owns the corner style (rounded / curved / sharp) and the crossing
+ * treatment (hops / halo). Crossings need every line at once, so this
+ * takes the whole map.
+ *
+ * Who goes over at a crossing: **the more horizontal segment** (the later
+ * line id on a tie), as on a circuit schematic. One fixed rule reads at a
+ * glance — every bridge is a bump on a horizontal run, every vertical run
+ * passes under — where "whichever line is later" scatters bumps in both
+ * directions with no visible logic. Horizontal runs are also the long,
+ * calm stretches between cards, so a bump there disturbs the least. When the
+ * over line has no room at that spot (a corner or its end is too close), the
+ * other line takes the treatment; when neither has room, the crossing is
+ * drawn plain.
+ *
+ *   hops   the over line jumps the under one with a semicircle of
+ *          HOP_RADIUS, drawn as two cubics (EdgeFlow's `measurePath` reads
+ *          M L H V Q C only, so no `A`). Crossings closer than
+ *          2 × HOP_RADIUS + MERGE_SLACK merge into one flat-topped bridge.
+ *   halo   `halo: true`: FkEdge draws a canvas-coloured casing under every
+ *          line. Left to paint order, the casing would let whichever line
+ *          React Flow draws LATER win each crossing, a different rule from
+ *          hops and a random-looking one. So the under line is also cut
+ *          (`strokeD`, HALO_CUT_HALF either side) and FkEdge draws both its
+ *          casing and its stroke from that: an under line has no casing at
+ *          the crossing, so it can never paint over the line above it. `d`
+ *          stays ONE continuous subpath (EdgeFlow and the hit area need one).
+ *
+ * Paths use absolute M / L / Q / C only, one subpath (`strokeD` aside), and
+ * numbers rounded to 0.01 px.
+ */
+import type { CornerMode, CrossingMode, Point, Rect, RoutedLine } from '../types.js';
+export interface RenderOptions {
+    crossings: CrossingMode;
+    corners: CornerMode;
+    /**
+     * The cards (optional). With them, a curved corner that would cut into a
+     * card is tightened until it clears.
+     */
+    obstacles?: readonly Rect[];
+    /**
+     * The canvas zoom (default 1). Hops are sized in screen px, so they stay
+     * readable as bridges when the diagram is zoomed out (see `hopRadiusFor`).
+     */
+    zoom?: number;
+}
+export interface RenderedPath {
+    /** One continuous subpath: draw the halo and the hit area with it; EdgeFlow follows it. */
+    d: string;
+    mid: Point;
+    halo?: boolean;
+    /**
+     * crossings = 'halo', on a line that passes under another: `d`
+     * with the breaks cut out (several `M` subpaths). Draw the visible stroke
+     * (and the halo casing) with this when present; keep `d` for EdgeFlow and
+     * the hit area.
+     */
+    strokeD?: string;
+}
+/** Radius (px) of a hop's semicircle at zoom 1. */
+export declare const HOP_RADIUS = 6;
+/** Hop radius in flow px for a canvas zoom: HOP_SCREEN_RADIUS on screen, between HOP_RADIUS and HOP_MAX_RADIUS. */
+export declare function hopRadiusFor(zoom: number | undefined): number;
+/** Half the cut (px) in an under line in halo mode: the casing's half width (3.5) plus a hair. */
+export declare const HALO_CUT_HALF = 4.5;
+/** Drop repeated points and points in the middle of a straight run. */
+export declare function simplify(points: readonly Point[]): Point[];
+/** A polyline with each corner rounded by up to `radius`, no crossings treatment. */
+export declare function roundedPath(points: readonly Point[], radius?: number): string;
+/** The point halfway along a polyline, by length. */
+export declare function polylineMidpoint(points: readonly Point[]): Point;
+export declare function renderPaths(lines: Map<string, RoutedLine>, opts: RenderOptions): Map<string, RenderedPath>;

package/dist/types/lib/edgeRouting/render/tunnels.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Edge routing — "x-ray": the stretches of a line that pass under a card.
+ *
+ * Cards are drawn above the lines, so any stretch of a line inside a card's
+ * box is hidden. `computeTunnels` clips the line's polyline against every
+ * box (tables and sticky notes alike, the line's own two ends included: a
+ * line that doubles back across its own table is hidden there too) and
+ * returns each hidden stretch as a polyline. `EdgeOverlay` draws them above
+ * the cards, with a "portal" where the line dives under a border and where it
+ * comes back out.
+ *
+ * - Boxes are shrunk by `EDGE_TOLERANCE` first, so a line that grazes a
+ *   corner is not "under" anything; a straight stretch parallel to a border
+ *   and within `BORDER_HUG` of it runs "along" the border, not under the card.
+ * - Overlapping or nearly touching boxes (a gap under `MERGE_GAP`) give one
+ *   tunnel, not a row of portals 4 px apart.
+ * - Stretches shorter than `MIN_TUNNEL` (a rounded corner clipping a box
+ *   corner) are dropped.
+ * - A stretch at the line's own end that is only under the line's own two
+ *   cards is dropped: when two related cards nearly touch, the 20 px stub
+ *   starts inside the other card and the line hooks round inside the pair.
+ *   Showing that hook says nothing the reader does not know (the line joins
+ *   those two cards) and puts dashes in two headers.
+ *
+ * Pure and allocation-light: it runs for every line on every frame of a drag.
+ * A box is tested against a segment only when their bounding boxes meet.
+ */
+import type { EdgeSpec, Point, Rect, RoutedLine } from '../types.js';
+/** A line closer than this (px) to a border counts as outside the box. */
+export declare const EDGE_TOLERANCE = 1;
+/**
+ * A straight stretch running parallel to a border and closer to it than this
+ * (px) is "along the border", not under the card: drawn, its ghost reads as
+ * a second, dashed border a few px inside the real one (seen on 'big': 127 px
+ * of it 3 px inside dim_supplier's bottom). Like every threshold it flips
+ * somewhere during a drag; pops stay rare (~1 in 1500 nudges on the scenarios).
+ */
+export declare const BORDER_HUG = 6;
+/** Hidden stretches closer together than this (px) along the line become one tunnel. */
+export declare const MERGE_GAP = 12;
+/** Hidden stretches shorter than this (px) are not worth a tunnel. */
+export declare const MIN_TUNNEL = 6;
+/**
+ * The hidden stretches of `line` as polylines: hidden by `obstacles` (every
+ * card box). Each polyline starts where the line dives under a border and ends
+ * where it comes back out (or where the line itself starts / ends, if an end
+ * sits inside another card).
+ */
+export declare function computeTunnels(line: RoutedLine, spec: EdgeSpec | undefined, obstacles: Rect[]): Point[][];

package/dist/types/lib/edgeRouting/routeAll.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `routeAll`: route and draw every line of one diagram in one pass. Its own
+ * module (no React Flow, no React) so the line-routing worker can bundle it
+ * without the canvas code around it.
+ */
+import type { LineRouter, LineStyleOptions, RouteResult, RoutingInput } from './types.js';
+/** A router that throws must never take the canvas down: fall back. */
+export declare function safely<T>(fn: () => T, fallback: T, onError: (err: unknown) => void): T;
+export interface RouteAllOptions {
+    /** The router (and its memory of the last pass). Default: a fresh route-around router, so the call keeps no state. */
+    router?: LineRouter;
+    /** Clock for `millis` (default: none, `millis` is 0). */
+    now?: () => number;
+    /** The canvas zoom: hops are sized for it (`hopRadiusFor`). Default 1. */
+    zoom?: number;
+    /** Called with a router or renderer error (the pass still returns, with fewer or no routes). */
+    onError?: (err: unknown) => void;
+}
+/** Route and draw every line of `input` in one pass. Never throws. */
+export declare function routeAll(input: RoutingInput, options: LineStyleOptions, ctx?: RouteAllOptions): RouteResult;

package/dist/types/lib/edgeRouting/routers/orthogonal/geom.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Route-around router — small geometry helpers shared by the grid, the search
+ * and the nudging pass. Orthogonal only: every segment is horizontal or vertical.
+ */
+import { type Anchor, type Point, type Rect, type Side } from "../../types.js";
+/** Leg orientation: 0 = horizontal, 1 = vertical. */
+export type Orient = 0 | 1;
+/** The sides tried for a port, in a fixed order (determinism). */
+export declare const SIDES: readonly Side[];
+/** Orientation of the straight leg that leaves (or enters) a side. */
+export declare function legOrient(side: Side): Orient;
+/** Direction of travel along that leg when leaving the card (+1 = towards +x / +y). */
+export declare function outDir(side: Side): 1 | -1;
+/** Where a side lies across its leg: x of a left/right side, y of a top/bottom side. */
+export declare function sideLine(r: Rect, side: Side): number;
+/** The span of a side along itself: [y0, y1] for left/right, [x0, x1] for top/bottom. */
+export declare function sideSpan(r: Rect, side: Side): [number, number];
+/** Where anchors may sit along a side: the span minus a corner inset (the centre for a short side). */
+export declare function anchorRange(r: Rect, side: Side): [number, number];
+export declare function sideMid(r: Rect, side: Side): number;
+/** The port: the point `c` along the side, pushed PATH_GAP out (where the drawn line starts). */
+export declare function portPoint(r: Rect, side: Side, c: number): Point;
+/** The anchor on the card border behind a port. */
+export declare function anchorBehind(port: Point, side: Side): Anchor;
+export declare function pad(r: Rect, by: number): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** Do two rects (each grown by its own amount) overlap with positive area? */
+export declare function rectsOverlap(a: Rect, growA: number, b: Rect, growB: number): boolean;
+/** Drop repeated points and the middle point of any straight run. */
+export declare function simplifyOrthogonal(points: Point[]): Point[];
+/**
+ * Does the axis-aligned segment a→b pass through the inside of `r` (shrunk by
+ * `tol` on every side)? Touching the border does not count.
+ */
+export declare function segmentEntersRect(a: Point, b: Point, r: Rect, tol: number): boolean;
+/**
+ * A uniform bucket grid over the cards, for "which cards are near this
+ * segment" queries in the nudging and validation passes.
+ */
+export declare class Buckets {
+    readonly rects: readonly Rect[];
+    private readonly x0;
+    private readonly y0;
+    private readonly cols;
+    private readonly rows;
+    private readonly cells;
+    private readonly seen;
+    private stamp;
+    private readonly cell;
+    constructor(rects: readonly Rect[], cell?: number);
+    private cellOf;
+    /** Indices of the rects whose bucket cells meet the box (a superset of the rects that meet it). */
+    query(x0: number, y0: number, x1: number, y1: number, out?: number[]): number[];
+}

package/dist/types/lib/edgeRouting/routers/orthogonal/grid.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Route-around router — the routing grid.
+ *
+ * A sparse orthogonal grid (Wybrow–Marriott–Stuckey style): its lines are the
+ * padded edges of every card, channel midlines between neighbouring cards,
+ * the centre of every card side, and the line where two related cards'
+ * sides overlap (so a straight line between them is on offer). A node is
+ * every crossing of an x-line and a y-line. Every padded card's edges are
+ * grid lines, so each elementary grid edge is either wholly inside a padded
+ * card or wholly outside it; `hBlk` / `vBlk` count the padded cards each one
+ * runs through, so a card can be lifted out again (`markRect(…, -1)`) for a
+ * relaxed retry.
+ *
+ * Node index n = j * nx + i (column i, row j).
+ *   hBlk[n]  the edge from (i, j) to (i + 1, j)
+ *   vBlk[n]  the edge from (i, j) to (i, j + 1)
+ *   hUse / vUse  how many lines routed so far run along that edge.
+ */
+export interface Grid {
+    xs: Float64Array;
+    ys: Float64Array;
+    nx: number;
+    ny: number;
+    hBlk: Uint16Array;
+    vBlk: Uint16Array;
+    hUse: Uint8Array;
+    vUse: Uint8Array;
+    /** Anchor zones: the band in front of a card side where lines attach (closed to other lines). */
+    hZone: Uint8Array;
+    vZone: Uint8Array;
+}
+/** Sort and merge values closer than MERGE_EPS (each cluster keeps its smallest value). */
+export declare function uniqueSorted(values: number[]): Float64Array;
+/**
+ * The grid lines: every `hard` value (a padded card edge, which the blocking
+ * needs exactly) plus each `soft` value (side centres, midlines, straight-line
+ * options) that is more than `softEps` from every line kept so far. A cluster
+ * of lines a few px apart adds nodes but no real routing choice, and A* pays
+ * for every node.
+ */
+export declare function gridLines(hard: number[], soft: number[], softEps: number): Float64Array;
+/** The largest index i with arr[i] <= v (+ a hair), or -1. */
+export declare function floorIndex(arr: Float64Array, v: number): number;
+/** The smallest index i with arr[i] >= v (- a hair), or arr.length. */
+export declare function ceilIndex(arr: Float64Array, v: number): number;
+export declare function makeGrid(xs: Float64Array, ys: Float64Array): Grid;
+/**
+ * Add (delta +1) or remove (-1) a padded card: every grid edge strictly
+ * inside the box. The box's edges must be grid lines (they snap to the line
+ * they were merged into).
+ */
+export declare function markRect(g: Grid, x0: number, y0: number, x1: number, y1: number, delta: 1 | -1): void;
+/** Count a routed line's grid edges (consecutive nodes of a search result). */
+export declare function markUse(g: Grid, nodes: readonly number[]): void;
+/**
+ * Close (delta +1) or reopen (-1) a box that is not grid-aligned: every grid
+ * edge that runs inside it, or crosses into it, is marked. Used for the
+ * anchor zone in front of a card side.
+ */
+export declare function markZone(g: Grid, x0: number, y0: number, x1: number, y1: number, delta: 1 | -1): void;
+/**
+ * Block (+1) or unblock (-1) a box that is not grid-aligned, like `markZone`
+ * but in the hard block counts (used for the band round a line's own cards).
+ */
+export declare function markBand(g: Grid, x0: number, y0: number, x1: number, y1: number, delta: 1 | -1): void;
+/** The index of the value within `eps` of `v` (the nearest one), or -1. */
+export declare function nearIndex(arr: Float64Array, v: number, eps: number): number;
+/**
+ * Count a polyline's grid edges as used, from its geometry (a route kept from
+ * an earlier pass, whose grid has changed since, or one routed on another
+ * line's local grid). Segments not within `eps` of a grid line are skipped:
+ * usage is only a hint to the lines routed after it.
+ */
+export declare function markPathUse(g: Grid, pts: readonly {
+    x: number;
+    y: number;
+}[], eps?: number): void;

package/dist/types/lib/edgeRouting/routers/orthogonal/nudge.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Route-around router — after every line has a route, make the routes read
+ * as separate wires.
+ *
+ * For one dimension at a time (vertical segments, then horizontal):
+ *
+ * 1. Centre. A middle segment with both neighbours heading the same way (a
+ *    "Z") can slide anywhere between them without changing the length or the
+ *    bends; slide it to the middle of the free space (between the cards
+ *    around it, and between its neighbours' far ends). Lines then run down
+ *    the middle of a channel, and a step between two cards turns half-way,
+ *    as today's smooth step does.
+ *
+ * 2. Nudge. Segments that share a channel (parallel, overlapping, within a
+ *    few px) and the end segments that meet one card side are put in an
+ *    order that does not make them cross, then spread apart: LINE_SEP in a
+ *    channel, ANCHOR_SEP between anchors on a card side (moving an end
+ *    segment slides its anchor along the side). The order comes from where
+ *    the lines go at the ends of the shared stretch (Wybrow, Marriott &
+ *    Stuckey's "ordering paths in a shared channel"): if one line turns off
+ *    first, the other must sit on the far side of that turn. Where two lines
+ *    turn together, the comparison follows them round the corner.
+ *
+ * Every move is bounded so a segment never comes closer than CLEAR to a
+ * card (sweep-free), anchors stay off the corners, and the first / last bend
+ * stays MIN_LEG past the stub.
+ */
+import type { Point, Rect, Side } from "../../types.js";
+import { type Buckets } from "./geom.js";
+export interface NudgePath {
+    /** From the source port to the target port; mutated in place. */
+    pts: Point[];
+    src: Rect;
+    srcSide: Side;
+    tgt: Rect;
+    tgtSide: Side;
+    /** Tie-break order (by edge id). */
+    rank: number;
+    /** Indices of cards this line may pass under (ends buried under another card). */
+    ignore: ReadonlySet<number> | null;
+    /** Indices of its own two cards: kept OWN_CLEAR away, except along the stubs. */
+    own: readonly [number, number];
+}
+export interface NudgeContext {
+    /** Cards, self-loops, then (from `zoneFrom` on) anchor zones. */
+    rects: readonly Rect[];
+    buckets: Buckets;
+    /** Index of the first anchor zone in `rects`: zones need no extra clearance. */
+    zoneFrom: number;
+}
+/**
+ * Where a line steps sideways (segment k between two parallel segments that
+ * head the same way, a "Z"), slide one of the two onto the other's line:
+ * two bends fewer and never longer. Allowed when the area the segment
+ * sweeps is clear of cards, loops and anchor zones (by MARGIN), an end
+ * segment's anchor stays on its side, the neighbour beyond keeps its
+ * direction and length (a stub keeps MIN_LEG), and the line crosses no more
+ * of the others than before. Weighted A* and the grid both leave such jogs.
+ */
+export declare function straightenPass(paths: NudgePath[], ctx: NudgeContext): void;
+export declare function centrePass(paths: NudgePath[], vert: boolean, ctx: NudgeContext): void;
+export declare function nudgePass(paths: NudgePath[], vert: boolean, ctx: NudgeContext): void;

package/dist/types/lib/edgeRouting/routers/orthogonal/params.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Route-around router — tuning knobs, in flow px (or px-equivalent costs).
+ *
+ *   card ┃<- PATH_GAP 20 ->● stub end ── MIN_LEG 10 ──┐ first bend (≥ 30 out)
+ *        ┃<- MARGIN 16  -> routes keep this far from every card
+ *        ┃<- ZONE 42    -> no other line runs in front of a side with stubs
+ *
+ * The values were tuned against hand-placed scenarios
+ * (`test/fixtures/edgeRouting/scenarios.ts`): screenshots, crossings / bends /
+ * length, and A* expansions.
+ */
+/** Routes keep at least this far from every card (the routing grid pads each card by it). */
+export declare const MARGIN = 16;
+/** Nudging parallel lines apart never brings a line closer than this to a card. */
+export declare const CLEAR = 16;
+/** Gap between parallel lines that share a channel (fit-to-view often draws at ~0.7×). */
+export declare const LINE_SEP = 12;
+/** Gap between twins (two lines joining the same two cards): their role labels must clear each other. */
+export declare const TWIN_SEP = 30;
+/** Gap between two anchors on one card side: room for the `*` / `1` of each. */
+export declare const ANCHOR_SEP = 24;
+/** Anchors keep this far from a card's corners. */
+export declare const ANCHOR_INSET = 20;
+/** Straight run past the stub before a line may bend. */
+export declare const MIN_LEG = 10;
+/** Shortest run the centring pass leaves next to a bend. */
+export declare const MIN_RUN = 10;
+/**
+ * A line keeps this far from its own two cards everywhere but along its two
+ * stubs (PATH_GAP + MIN_LEG - 1): it never runs between a card and its stubs.
+ */
+export declare const OWN_CLEAR = 29;
+/**
+ * Depth of the anchor zone in front of a card side that has lines attached:
+ * the stubs, their `*` / `1` and their first bends live there, and a line
+ * running past inside it reads as joined to them. Other lines pay ZONE_COST
+ * to run there; a line's own two cards' zones are open to it.
+ */
+export declare const ZONE = 42;
+/**
+ * Extra cost per px of running inside another card side's anchor zone (< 0:
+ * zones are closed outright). Closed zones send lines in a crowded diagram on
+ * long detours round the whole thing; at 2 a line cuts through only when the
+ * way round is about three times as long.
+ */
+export declare const ZONE_COST = 2;
+/** Cost of one bend, in px of length. */
+export declare const BEND = 40;
+/**
+ * Cost of crossing a line routed earlier: a crossing is worth a two-bend
+ * detour (at 40 the tangle scenario had twice the crossings).
+ */
+export declare const CROSS = 80;
+/**
+ * A crossing on another line's stub (inside an anchor zone, or on this line's
+ * own leg) costs this many times CROSS: right next to a `*` / `1` it reads as
+ * a T junction, as if the lines joined there.
+ */
+export declare const STUB_CROSS = 3;
+/** Extra cost per px of grid edge earlier lines already use (spreads lines over the channels). */
+export declare const SHARE = 0.25;
+/**
+ * Cost of an anchor slot right on top of another line's anchor on the same
+ * side (falling to 0 at ANCHOR_SEP away): a side has only so much room, so a
+ * later line takes a free slot or another side. Twins are exempt (they pair up).
+ */
+export declare const SLOT = 400;
+/**
+ * Hysteresis for a line routed again (its card moved, or a card came near it):
+ * taking a side other than the one it had costs STICK_SIDE (more than a bend,
+ * less than two), and a slot on its old side costs STICK_SLOT per px away from
+ * where its anchor was (carried along with the card). Without these a drag
+ * re-plans every line on the moved card from scratch each frame, and a 1 px
+ * move can swap the grid line a slot sits on: anchors jumped 20-50 px and
+ * lines flipped sides on ~10% of drag frames in the tangle and 40-card scenarios.
+ */
+export declare const STICK_SIDE = 100;
+export declare const STICK_SLOT = 2;
+/** …applied only when at most this many boxes changed since the last pass (`changed` holds each moved box twice: old and new). */
+export declare const STICK_MAX_CHANGED = 8;
+/** Cost per px an anchor sits off the centre of its side: a straight line is worth a shift… */
+export declare const SHIFT = 1.1;
+/** …plus this per px², so an aligned straight line settles in the middle of the overlap. */
+export declare const SHIFT_SQ = 0.002;
+/** Grid lines closer than this are one line. */
+export declare const MERGE_EPS = 1;
+/**
+ * A soft grid line (side centre, midline, straight-line option) within this
+ * of another line is dropped: a cluster of near-identical lines adds A* nodes,
+ * not routing choices (on the 40-card scenario this alone cut expansions by 3×).
+ */
+export declare const SOFT_EPS = 12;
+/** Parallel segments closer than this share a channel: they are ordered by where they go. */
+export declare const NEAR = 3;
+/** Segments this close that a group's spreading swapped are re-solved together. */
+export declare const RELATE_WINDOW = 40;
+/** The furthest the nudging pass moves a segment. */
+export declare const MAX_SHIFT = 120;
+/**
+ * Weighted A*: the heuristic is scaled by this. Crossing and sharing costs
+ * make the length + bends estimate loose, and an unweighted search floods
+ * the channels; 1.1 keeps the routes a designer would draw (1.2 already
+ * sends the odd long line the long way round).
+ */
+export declare const HEURISTIC_WEIGHT = 1.1;
+/**
+ * Lines spanning more than LONG_FROM px (centre to centre, Manhattan) get up
+ * to LONG_EXTRA more weight, reached LONG_RAMP px further on: on the 40-card
+ * scenario a quarter fewer expansions for a few more crossings, while every
+ * line of a normal diagram (the star's longest spans 1,600 px) stays at 1.1.
+ */
+export declare const LONG_FROM = 1600;
+export declare const LONG_RAMP = 1200;
+export declare const LONG_EXTRA = 0.3;
+/**
+ * …and their crossings cost up to this much less: across a whole diagram
+ * most are unavoidable, and pricing them in full doubles the search.
+ */
+export declare const LONG_CROSS_CUT = 0.7;
+/** A* gives up (and the line falls back) after this many expansions. */
+export declare const MAX_POPS = 40000;
+/**
+ * Diagrams with more cards (and self-loops) than this route each line on its
+ * own local grid (router.ts, `localGrid`): one grid over the whole diagram
+ * grows with the square of its size (every card's edges cross every other
+ * card's), to millions of nodes on an uneven 1,000-card layout.
+ */
+export declare const LOCAL_FROM_CARDS = 150;
+/** A local grid starts this far (px) round its line's two cards: about one card and a gap. */
+export declare const LOCAL_MARGIN = 400;
+/** …and its margin grows by this factor each time the route runs along its edge. */
+export declare const LOCAL_GROWTH = 2.5;
+/** A local grid larger than this (nodes) is not built: the line keeps what it found, or falls back. */
+export declare const LOCAL_MAX_NODES = 1500000;
+/**
+ * On local grids (large diagrams), long lines are greedier still: from
+ * LOCAL_LONG_FROM px they get up to LOCAL_LONG_EXTRA more heuristic weight
+ * and crossings up to LOCAL_LONG_CROSS_CUT cheaper. A line across a 2,000-card
+ * layered diagram otherwise runs out of MAX_POPS among the other lines and
+ * falls back (161 of 2,732 did); with these none do, for ~2.5% more crossings.
+ */
+export declare const LOCAL_LONG_FROM = 1200;
+export declare const LOCAL_LONG_EXTRA = 0.9;
+export declare const LOCAL_LONG_CROSS_CUT = 0.85;
+/**
+ * On local grids, a line whose search runs out of MAX_POPS gets one greedy
+ * retry before it falls back: this heuristic weight, and crossings at this
+ * fraction of CROSS. A few more crossings beat a line drawn through every card
+ * between its two ends (lines between neighbouring columns 5,000 px apart).
+ */
+export declare const RESCUE_WEIGHT = 3;
+export declare const RESCUE_CROSS = 0.1;

package/dist/types/lib/edgeRouting/routers/orthogonal/router.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Route-around router — the whole pass.
+ *
+ *   1. Grid: the padded cards' edges, channel midlines, side centres, and per
+ *      line the middle of the gap between its two cards and the straight-line
+ *      option where their sides overlap (grid.ts). Self-loops are left to the
+ *      canvas, but the space their loop takes is an obstacle.
+ *   2. Route every line, shortest first, with A* from any free anchor slot on
+ *      any side of its source to any on its target (search.ts). The router
+ *      picks the side: a line may leave the side the transformer chose when
+ *      another is clearly better. Lines routed later pay to cross or run
+ *      along earlier ones, so they spread over the free channels, and once a
+ *      card side has a line attached, the zone in front of it (stubs and
+ *      `*` / `1` labels) is closed to every other line.
+ *      Before the first line is routed, the zones in front of the sides the
+ *      canvas picked for every line are marked too, and a crossing on a stub
+ *      (between a card and its `*` / `1`, or on the leg out of it) costs
+ *      STUB_CROSS times more: it reads as a T junction.
+ *      In a drag, lines away from the moved card keep their routes; a line
+ *      routed again prefers the sides and slots it had (hysteresis), so it
+ *      does not jump about as its card moves a pixel at a time.
+ *   3. Nudge: centre free segments, then order and spread lines that share a
+ *      channel or a card side, so they read as separate wires and never
+ *      cross right at a card (nudge.ts).
+ *   4. Check: no segment may pass through a card other than one the line had
+ *      to ignore. A line that can't be routed at all (its end is buried under
+ *      another card) falls back to today's simple three-segment path.
+ */
+import { type RoutedLine, type RoutingInput } from "../../types.js";
+export interface AvoidResult {
+    lines: Map<string, RoutedLine>;
+    /** Lines with no route around the cards: they got today's three-segment path. */
+    fallbacks: Set<string>;
+    /** Lines routed only by letting them pass under cards that crowd their ends. */
+    relaxed: Map<string, Set<string>>;
+    /** Grid size and A* expansions, for tests and the perf readout. */
+    stats: {
+        gridX: number;
+        gridY: number;
+        pops: number;
+        reused: number;
+    };
+}
+/** A route-around router with its own memory of the last pass. */
+export interface AvoidRouter {
+    /** Route every line; lines away from what changed since the last pass keep their routes. */
+    route(input: RoutingInput): AvoidResult;
+    /** Drop the last pass: the next `route` routes every line from scratch. */
+    reset(): void;
+}
+export declare function createAvoidRouter(): AvoidRouter;