@draftably/editor 0.4.0 → 0.6.0

package/dist/types/src/engines/layout/types.d.ts

@@ -0,0 +1,133 @@
+import type { Diagram, Direction, IntentPlacement, LayoutAlgorithmId, LayoutIntent, LayoutSettings, NodeGeometry, NodeLayout, Point, Rect } from '../../model/types.ts';
+export type LayoutSettingKey = 'boundaryPull' | 'hierarchySweeps' | 'groupGap' | 'rankGap' | 'edgeLength' | 'repulsion' | 'flowStrength' | 'alignment' | 'compactness' | 'gridStrength' | 'ordering' | 'fold' | 'rootId';
+export interface LayoutAlgorithm {
+    id: LayoutAlgorithmId;
+    name: string;
+    family: string;
+    short: string;
+    detail: string;
+    controls: LayoutSettingKey[];
+}
+export interface LayoutMetrics {
+    overlaps: number;
+    overlapArea: number;
+    width: number;
+    height: number;
+    aspect: number;
+    area: number;
+    linkLength: number;
+}
+export type LayoutScope = 'all' | 'selection' | 'neighbourhood' | 'container';
+export interface LayoutOptions extends Partial<LayoutSettings> {
+    scope?: LayoutScope;
+    containerId?: string;
+    selected?: string[];
+    fixedIds?: string[];
+    viewport?: {
+        w: number;
+        h: number;
+    };
+    warmStart?: boolean;
+    settle?: boolean;
+    maxIterations?: number;
+    trace?: boolean;
+    rebuild?: boolean;
+    /** Travel per tick below which a settling solve counts the tick as quiet; 0.08 when unset. */
+    tolerance?: number;
+    /** False restores the v7 order within ranks: a rebuild never keeps the authored order. */
+    orderPrior?: boolean;
+}
+export type Termination = 'settled' | 'objective plateau' | 'iteration limit' | 'bounded pass';
+/** Why one solve of one container's children stopped. */
+export interface SolverStop {
+    parentId: string | null;
+    iterations: number;
+    reason: Exclude<Termination, 'bounded pass'>;
+}
+export interface LayoutReport {
+    intent: Array<{
+        role: string;
+        id: string;
+        placement: IntentPlacement;
+        error: number;
+        satisfied: boolean;
+        pinned: boolean;
+    }>;
+    backwardEdges: number;
+    directedEdges: number;
+    feedbackEdges: number;
+    algorithm: LayoutAlgorithmId;
+    name: string;
+    mode: 'pass' | 'rebuild' | 'journey';
+    scope: LayoutScope;
+    moved: number;
+    maxDisplacement: number;
+    rmsDisplacement: number;
+    movementLimit: number | null;
+    iterations: number;
+    batches: number;
+    before: LayoutMetrics;
+    after: LayoutMetrics;
+    warnings: string[];
+    milliseconds: number;
+    deterministic: boolean;
+    termination: Termination;
+    solverStops: SolverStop[];
+    /** Added by the app: where the computation ran. */
+    thread?: string;
+    /** Added by the app when a timeline step is kept. */
+    selectedStep?: number;
+}
+export interface TraceFrame {
+    nodes: NodeGeometry;
+    iteration: number;
+    phase: string;
+    metrics: LayoutMetrics;
+}
+export interface LayoutResult {
+    document: Diagram;
+    report: LayoutReport;
+    trace?: TraceFrame[];
+}
+/**
+ * Settings inside a solve. `radial` is an old name that `settings` maps to `tree`, so no solve
+ * runs with it; the radial target and its branches stay as the original engine had them.
+ */
+export interface Settings extends Omit<LayoutSettings, 'algorithm'> {
+    algorithm: LayoutAlgorithmId | 'radial';
+}
+/** A box a solve places: a shape or a whole group, with its top-left corner and size. */
+export type Item = Rect & {
+    id: string;
+    fixed?: boolean;
+};
+/** A link between two items of one solve. */
+export interface Link {
+    from: string;
+    to: string;
+    directed?: boolean;
+}
+export interface Topology<E extends Link = Link> {
+    intent: LayoutIntent;
+    /** Item IDs, sorted. */
+    ids: string[];
+    index: Map<string, number>;
+    /** Directed neighbours out of, into, and (with undirected links) beside each item. */
+    out: Map<string, string[]>;
+    inc: Map<string, string[]>;
+    adj: Map<string, string[]>;
+    rank: Map<string, number>;
+    /** `from + '\0' + to` of each directed link that runs against the ranks. */
+    feedback: Set<string>;
+    edges: E[];
+    forward: E[];
+    components: string[][];
+    /** Source order of each item, when a rebuild keeps the authored order within ranks. */
+    declared?: Map<string, number>;
+    /** Which side of a centred start each item sits on: 1, -1, or 0 for the start. */
+    branchSides?: Map<string, number>;
+}
+/** Centre points by item ID. */
+export type Centres = Map<string, Point>;
+export type Axis = 'x' | 'y';
+export type { Diagram, Direction, LayoutIntent, NodeLayout, Point, Rect };

package/dist/types/src/engines/layout/util.d.ts

@@ -0,0 +1,19 @@
+import type { Point, Rect } from './types.ts';
+export declare const copy: <T>(x: T) => T;
+export declare const clamp: (x: number, lo: number, hi: number) => number;
+export declare const cmp: (a: string, b: string) => 0 | 1 | -1;
+export declare const magnitude: (x: number, y: number) => number;
+export declare const wait: () => Promise<unknown>;
+export declare function bounds(items: Rect[]): Rect;
+export declare const midpoint: (r: Rect) => Point;
+/** How far two boxes, kept `gap` apart, reach into each other; null when they are clear. */
+export interface Penetration {
+    x: number;
+    y: number;
+    dx: number;
+    dy: number;
+    area: number;
+}
+export declare function penetration(a: Rect, b: Rect, gap?: number): Penetration | null;
+/** A fixed number in [0, 1) for an ID: FNV-1a. It stands in for a random start. */
+export declare function hash(id: string): number;

package/dist/types/src/engines/layout-engine.d.ts

@@ -0,0 +1,15 @@
+import { compute } from './layout/compute.ts';
+import { normalizeIntent } from './layout/intent.ts';
+import { settings } from './layout/settings.ts';
+import { topology } from './layout/topology.ts';
+export declare const LayoutLab: {
+    algorithms: import("./layout-engine.ts").LayoutAlgorithm[];
+    defaults: import("../model/types.ts").LayoutSettings;
+    settings: typeof settings;
+    compute: typeof compute;
+    normalizeIntent: typeof normalizeIntent;
+    placements: Record<import("../model/types.ts").IntentPlacement, [number, number]>;
+    topology: typeof topology;
+};
+export type { LayoutAlgorithm, LayoutMetrics, LayoutOptions, LayoutReport, LayoutResult, LayoutScope, LayoutSettingKey, SolverStop, Termination, TraceFrame, } from './layout/types.ts';
+export type { Point } from '../model/types.ts';

package/dist/types/src/engines/routing/compute.d.ts

@@ -0,0 +1,6 @@
+import type { RouteInput, RoutingOptions, RoutingResult } from './types.ts';
+/**
+ * Routes every edge between boxes that stay where they are: each edge in turn (locked ones and
+ * short ones first), then the improvement, repair, nudge and tidy passes unless `quick`.
+ */
+export declare function compute(input: RouteInput, rawOptions?: RoutingOptions): RoutingResult;

package/dist/types/src/engines/routing/conflicts.d.ts

@@ -0,0 +1,36 @@
+import type { Point, RoutingSettings } from './types.ts';
+/** A routed line, as the pair checks read it: only its points. */
+export type Line = {
+    points: Point[];
+};
+export interface Span {
+    /** Segment count. */
+    n: number;
+    h: Uint8Array;
+    lo: Float64Array;
+    hi: Float64Array;
+    at: Float64Array;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export declare function spanOf(ps: Point[]): Span;
+/** Flattens `used` for the checks below. False when it already was: the caller that got true calls `unflatten`. */
+export declare function flatten(used: Line[]): boolean;
+export declare const unflatten: (used: Line[]) => boolean;
+export declare function parallelNear(a: Point, b: Point, c: Point, d: Point, gap: number): {
+    overlap: number;
+    separation: number;
+    deficit: number;
+} | null;
+export declare function parallelConflicts(points: Point[], used: Line[], gap: number): {
+    lanePairs: number;
+    laneDeficit: number;
+    minGap: number | null;
+};
+export declare function siblingDeficit(points: Point[], used: Line[], min: number, gap: number): number;
+export declare function conflicts(points: Point[], used: Line[], bound?: number, s?: RoutingSettings): {
+    crossings: number;
+    shared: number;
+};

package/dist/types/src/engines/routing/context.d.ts

@@ -0,0 +1,37 @@
+import type { Box, NearBox, Obstacle, Point, Route, RouteEdge, RouteGroupInput, RouteInput, RouteMetrics, RoutingOptions, Side } from './types.ts';
+/** The drawing as the passes change it. */
+export interface RouteState {
+    routes: Route[];
+    /** Edges whose planned route was taken as it is: no pass moves them. */
+    fixedPlans: Set<string>;
+}
+export declare function gate(obs: Obstacle[], start: Point, fs: Side, end: Point, ts: Side): Obstacle[];
+/**
+ * One routing run's view of the scene: the boxes and groups, the edges in routing order, the
+ * obstacles each edge sees, and the measures the passes compare drawings with.
+ */
+export declare function createContext(input: RouteInput, rawOptions: RoutingOptions): {
+    rawOptions: RoutingOptions;
+    facingFans: boolean;
+    titleBands: boolean;
+    began: number;
+    s: import("./types.ts").RoutingSettings;
+    rects: Map<string, Box>;
+    groups: Map<string, RouteGroupInput>;
+    near: NearBox[];
+    ancestors: (id: string) => string[];
+    previous: Map<string, import("./types.ts").PriorRoute>;
+    edges: RouteEdge[];
+    state: RouteState;
+    opened: WeakSet<Route>;
+    syncOpen: () => void;
+    beyond: (id: string, other: string, side: Side) => boolean;
+    crowdedSide: (id: string, side: Side) => boolean;
+    flowOf: (e: RouteEdge) => "right" | "down" | undefined;
+    scores: WeakMap<Route, number>;
+    obsFor: (e: RouteEdge, open?: boolean) => Obstacle[];
+    metrics: (rs: Route[]) => RouteMetrics;
+    total: (rs: Route[]) => number;
+    far: (r: Route) => boolean;
+};
+export type Context = ReturnType<typeof createContext>;

package/dist/types/src/engines/routing/cost.d.ts

@@ -0,0 +1,13 @@
+import { type Line } from './conflicts.ts';
+import type { NearBox, Point, RoutingSettings } from './types.ts';
+export declare const STANDOFF_WEIGHT = 0.5, BORDER_WEIGHT = 2;
+export declare function standoffCost(ps: Point[], near: NearBox[], bound?: number): number;
+export declare function standoffSegment(a: Point, b: Point, near: NearBox[]): number;
+/** Adds the grid lines a standoff band out from each box to `xs` and `ys`. */
+export declare function standoffLines(near: NearBox[], xs: number[], ys: number[]): void;
+export declare function ownCost(ps: Point[], s: RoutingSettings): number;
+export declare function cost(ps: Point[], used: Line[], s: RoutingSettings, near?: NearBox[]): number;
+export declare function costOf(ps: Point[], s: RoutingSettings, standoff: number, c: {
+    crossings: number;
+    shared: number;
+}, laneDeficit: number): number;

package/dist/types/src/engines/routing/doglegs.d.ts

@@ -0,0 +1,16 @@
+import { type Line } from './conflicts.ts';
+import type { NearBox, Obstacle, Point, RoutingSettings } from './types.ts';
+export interface Lanes {
+    xs: number[];
+    ys: number[];
+}
+export declare function laneLines(used: Line[], s: RoutingSettings): Lanes;
+export declare function doglegs(a: Point, b: Point, obs: Obstacle[], s: RoutingSettings, lanes: Lanes, near: NearBox[], room: number, visit: (path: Point[], k: number, horizontal?: boolean) => void): void;
+/**
+ * A lower bound on the crossings `conflicts` finds between a dogleg (2 to 4 points, before
+ * `compress`) and `used`: segments that cross well inside both. Two such crossings are never one
+ * point of one route, so each is a crossing `conflicts` counts. Runs along a fixed line use the
+ * level or upright segments that span it; a dogleg's middle run, which moves with its lane, uses
+ * the segments inside its fixed span.
+ */
+export declare function crossingFloor(used: Line[]): (a: Point, b: Point) => (raw: Point[], horizontal?: boolean) => number;

package/dist/types/src/engines/routing/find.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from './context.ts';
+import type { Obstacle, PriorRoute, Route, RouteEdge } from './types.ts';
+/** The sides an edge had before, to keep them (`portStability`) or, with `quick`, to reuse them. */
+type Prior = PriorRoute | null | undefined;
+export declare function find(ctx: Context, e: RouteEdge, used: Route[], old?: Prior, wall?: Obstacle[]): Route;
+export {};

package/dist/types/src/engines/routing/geometry.d.ts

@@ -0,0 +1,24 @@
+import type { Obstacle, Point, Rect, Side } from './types.ts';
+export declare const SIDES: Side[], EPS = 0.0001;
+export declare const round: (n: number) => number, clamp: (n: number, a: number, b: number) => number;
+export declare const clone: <T>(v: T) => T, cmp: (a: string, b: string) => 0 | 1 | -1;
+export declare const center: (r: Rect) => Point;
+export declare const same: (a: Point, b: Point) => boolean;
+/** Distance along the axes: every line is level or upright. */
+export declare const distance: (a: Point, b: Point) => number;
+/** The unit vector out of each side. */
+export declare const vector: Record<Side, Point>;
+export declare function inflate<R extends Rect>(r: R, p: number): R;
+/** Whether the level or upright segment a→b enters an obstacle. A slanted segment always does. */
+export declare function blocked(a: Point, b: Point, obs: Obstacle[]): boolean;
+/** A path with rounded points, without repeats or points inside a straight run. */
+export declare function compress(ps: Point[]): Point[];
+export declare function segments(ps: Point[]): [Point, Point][];
+export declare function below(a: number[], v: number): number;
+export declare function atMost(a: number[], v: number): number;
+export declare function lengthOf(ps: Point[]): number;
+export declare function bendsOf(start: Point, ps: Point[], end: Point): number;
+/** Length of a route's axis-aligned segments that lies inside rectangle `r`. */
+export declare function insideLength(ps: Point[], r: Rect): number;
+/** The length of a path, added segment by segment. */
+export declare const pathLength: (ps: Point[]) => number;

package/dist/types/src/engines/routing/heap.d.ts

@@ -0,0 +1,20 @@
+/** A binary min-heap on `f`, in typed arrays. `pop` leaves the entry in `key` and `g`. */
+export declare class Heap {
+    keys: Int32Array;
+    gs: Float64Array;
+    fs: Float64Array;
+    length: number;
+    key: number;
+    g: number;
+    constructor();
+    push(key: number, g: number, f: number): void;
+    pop(): void;
+}
+/** A binary min-heap of objects ordered by `before`. */
+export declare class Queue<T> {
+    items: T[];
+    before: (a: T, b: T) => boolean;
+    constructor(before: (a: T, b: T) => boolean);
+    push(v: T): void;
+    pop(): T;
+}

package/dist/types/src/engines/routing/improve.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from './context.ts';
+/**
+ * Routes again each line that is blocked, crosses, shares a run, runs too close to another or
+ * uses a far side, worst first, and keeps a new route when the whole drawing costs less. Returns
+ * how many it kept.
+ */
+export declare function improve(ctx: Context): number;

package/dist/types/src/engines/routing/nudge.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from './context.ts';
+/**
+ * Slide complete internal orthogonal segments into nearby free channels.
+ * Endpoints, sides, node coordinates and authored waypoint routes stay fixed.
+ * Returns how many routes it moved.
+ */
+export declare function nudge(ctx: Context): number;

package/dist/types/src/engines/routing/paths.d.ts

@@ -0,0 +1,8 @@
+import { type Context } from './context.ts';
+import type { Obstacle, Point, Route, RouteEdge, Side } from './types.ts';
+/**
+ * Whether a path leaves and enters along its sides' normals, stays level or upright, clears the
+ * obstacles (its own end boxes aside, on the first and last segment) and never doubles back.
+ */
+export declare function validPath(points: Point[], e: RouteEdge, fs: Side, ts: Side, obs: Obstacle[]): boolean;
+export declare function simplify(ctx: Context, points: Point[], e: RouteEdge, fs: Side, ts: Side, obs: Obstacle[], used: Route[]): Point[];

package/dist/types/src/engines/routing/planned.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from './context.ts';
+import type { Route, RouteEdge } from './types.ts';
+/**
+ * A line's planned route (`plan`, from a `flow` scope's ranks) is its route when it leaves and
+ * enters by facing sides and clears every box.
+ */
+export declare function planned(ctx: Context, e: RouteEdge): Route | null;

package/dist/types/src/engines/routing/ports.d.ts

@@ -0,0 +1,10 @@
+import type { End, Point, Rect, Route, RoutingSettings, ShapeKind, Side } from './types.ts';
+/** The fields of a route that hold the side and the offset of one end. */
+export declare const sideKey: (end: End) => `${End}Side`;
+export declare const offsetKey: (end: End) => `${End}Offset`;
+/** The point on `side` of a shape, `offset` along it from the middle, on the shape's outline. */
+export declare function port(rect: Rect & {
+    shape?: ShapeKind;
+}, side: Side, offset?: number): Point;
+export declare const TIGHT_PITCH = 12;
+export declare function slot(id: string, side: Side, r: Rect, used: Route[], s: RoutingSettings, other: Rect, tight?: boolean, spread?: boolean): number;

package/dist/types/src/engines/routing/repair.d.ts

@@ -0,0 +1,9 @@
+import type { Context } from './context.ts';
+/**
+ * Edges are routed one at a time, so a crossing priced when the later edge was routed is never
+ * repaired: moving either line alone costs more than the crossing. Try each crossing pair
+ * together: route one with the other's line as a wall, then the other round it, and keep the
+ * pair when the drawing as a whole costs less (NEXT.md item 9, R6).
+ * Returns how many pairs it rerouted.
+ */
+export declare function repair(ctx: Context): number;

package/dist/types/src/engines/routing/score.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from './context.ts';
+import type { Candidate, Point, PriorRoute, Route, RouteEdge, Side } from './types.ts';
+/**
+ * The score of a candidate route of edge `e` against the routed lines `used`: length, bends,
+ * standoff, crossings and lane conflicts, plus what its sides cost (far sides, conventions, fans,
+ * the layout's direction, a change from `old`). `from` and `to` are the sides the edge may use.
+ */
+export declare function createScorer(ctx: Context, e: RouteEdge, used: Route[], old: PriorRoute | null | undefined, from: Side[], to: Side[]): {
+    axis: (c: Candidate) => number;
+    score: (points: Point[], c: Candidate, bound?: number, floor?: boolean) => number;
+    sideFloor: (c: Candidate) => number;
+};

package/dist/types/src/engines/routing/search.d.ts

@@ -0,0 +1,16 @@
+import type { NearBox, Obstacle, Point, Route, RoutingSettings } from './types.ts';
+/** Search window margins round the two boxes, tried in turn; null is the whole grid. */
+export declare const WINDOWS: (number | null)[];
+/** A search window: only grid lines inside it are used. */
+export interface Window {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/**
+ * A* over the grid of lines through the ends, the obstacles' sides, the standoff bands and a lane
+ * beside every routed line. Returns the cheapest path from `start` to `end`, or null when none
+ * is found within `limit` visits.
+ */
+export declare function search(start: Point, end: Point, obs: Obstacle[], used: Route[], s: RoutingSettings, near?: NearBox[], limit?: number, win?: Window | null): Point[] | null;

package/dist/types/src/engines/routing/settings.d.ts

@@ -0,0 +1,4 @@
+import type { RoutingSettings } from './types.ts';
+export declare const defaults: RoutingSettings;
+/** Checked settings: defaults under `raw`, with every number held to its range. */
+export declare function settings(raw?: Partial<RoutingSettings>): RoutingSettings;

package/dist/types/src/engines/routing/sidepairs.d.ts

@@ -0,0 +1,20 @@
+import type { Context } from './context.ts';
+import type { Candidate, Obstacle, PriorRoute, Route, RouteEdge, Side } from './types.ts';
+/** One pair of sides an edge may use, with its ports and stubs, and how to look for its paths. */
+export interface SidePair {
+    c: Candidate;
+    /** Stacked neighbours closer than two stubs: the stubs meet halfway and no grid search runs. */
+    tight: boolean;
+    /** The obstacles its doglegs must clear. */
+    walls: Obstacle[];
+    /** The two ports face each other on one clear line. */
+    straight: boolean;
+    /** False for an edge with waypoints: only the grid search routes it. */
+    paths: boolean;
+}
+/**
+ * Port choice: for each allowed pair of sides, the port offsets the fans already on those sides
+ * leave free, the stubs out of them, and the obstacles gated to them. Pairs whose stubs are
+ * blocked, or whose diamond vertex is taken while another is free, are left out.
+ */
+export declare function sidePairs(ctx: Context, e: RouteEdge, used: Route[], edgeObs: Obstacle[], from: Side[], to: Side[], axis: (c: Candidate) => number, old: PriorRoute | null | undefined): SidePair[];

package/dist/types/src/engines/routing/tidy-ports.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from './context.ts';
+import type { Box, End, Point, Route } from './types.ts';
+/**
+ * Tries a tidy move: new points for some routes, by index, with their new offsets. It stands
+ * only when every moved route stays valid and nothing gets worse.
+ */
+export type Attempt = (changes: Map<number, Point[]>, extra?: Record<number, Partial<Route>>, throughWaypoints?: boolean, slack?: number) => boolean;
+/** Whether a shape's sides are straight, so a port may slide along them. */
+export declare const flat: (r: Box) => boolean;
+export declare const ends: End[];
+/** The point `k` steps in from one end of a path. */
+export declare const tip: (ps: Point[], end: End, k?: number) => Point;
+export declare function centrePorts(ctx: Context, attempt: Attempt): void;

package/dist/types/src/engines/routing/tidy.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from './context.ts';
+/**
+ * Tidy: make routes look drafted on purpose. Ports on a side sit symmetrically
+ * about its centre, edges fanning from one side turn on one line, and parallel
+ * runs in a corridor keep one pitch. A move stands only when every moved route
+ * stays valid and nothing gets worse: no crossing, shared run, lane conflict,
+ * short step or standoff cost is added.
+ * Returns how many moves stood.
+ */
+export declare function tidy(ctx: Context): number;

package/dist/types/src/engines/routing/tuning.d.ts

@@ -0,0 +1,9 @@
+import type { Flow, Side } from './types.ts';
+export declare const AXIS_PENALTY = 100, TRAILING: Record<Flow, Side>, LEADING: Record<Flow, Side>, BACK_PENALTY = 300, BACK_OUT: Record<Flow, Side[]>, BACK_IN: Record<Flow, Side[]>;
+export declare const HOOK_PENALTY = 80;
+export declare const ARRIVE_BELOW = 40, ARRIVE_RIGHT = 12, LEAVE_BACK = 12, DETOUR_WEIGHT = 0.5, LINGER_WEIGHT = 0.3, BOUND_SLACK = 1;
+export declare const FAN_PITCH = 10;
+export declare const DETOUR_RATIO = 1.75, DETOUR_SOFT = 1.2, BAND_COST = 120;
+export declare const PORT_SLACK = 4;
+export declare const FAR_PENALTY = 100, OWN_STANDOFF = 1;
+export declare const MAX_REPAIRS = 4, FAN_GROUP = 4, REPAIR_EDGES = 32;

package/dist/types/src/engines/routing/types.d.ts

@@ -0,0 +1,157 @@
+import type { EdgeLayout, Point, Rect, RoutingSettings, ShapeKind, Side } from '../../model/types.ts';
+export interface RouteNodeInput extends Rect {
+    id: string;
+    parentId?: string;
+    shape: ShapeKind;
+    /** The stub for lines that end on an open group's frame: the group's rectangle. */
+    frame?: boolean;
+}
+export interface RouteGroupInput extends Rect {
+    id: string;
+    parentId?: string;
+    collapsed: boolean;
+    /** Width of the header's icon and title from the group's left edge; the rest of the band is open. */
+    titleWidth?: number;
+    /** Height of the title band the router keeps clear; 28 when unset. */
+    titleHeight?: number;
+}
+export interface RouteEdgeInput {
+    id: string;
+    from: string;
+    to: string;
+    directed?: boolean;
+    /** The edge's text. A labelled edge keeps the full port gap in a fan. */
+    label?: string;
+    cfg: EdgeLayout;
+}
+export interface RouteInput {
+    nodes: RouteNodeInput[];
+    groups: RouteGroupInput[];
+    edges: RouteEdgeInput[];
+}
+export interface Route {
+    id: string;
+    from: string;
+    to: string;
+    fromSide: Side;
+    toSide: Side;
+    fromOffset: number;
+    toOffset: number;
+    points: Point[];
+    blocked: boolean;
+    reason?: string;
+}
+export interface PriorRoute {
+    id: string;
+    fromSide: Side;
+    toSide: Side;
+}
+/** What a set of routes costs: the counts the passes compare and the report shows. */
+export interface RouteMetrics {
+    crossings: number;
+    shared: number;
+    lanePairs: number;
+    laneDeficit: number;
+    minimumConflictingGap: number | null;
+    requestedEdgeGap: number;
+    blocked: number;
+    bends: number;
+    length: number;
+}
+export interface RoutingReport extends RouteMetrics {
+    initial: RouteMetrics;
+    accepted: number;
+    /** Crossing pairs the repair pass rerouted. Absent with `quick` or `facing: false`. */
+    repaired?: number;
+    nudged: number;
+    tidied?: number;
+    edges: number;
+    milliseconds: number;
+    passes: number;
+}
+export interface RoutingResult {
+    routes: Route[];
+    report: RoutingReport;
+}
+export interface RoutingOptions extends Partial<RoutingSettings> {
+    previous?: PriorRoute[];
+    quick?: boolean;
+    /** A reading direction for every edge without its own `cfg.flow`; forward edges run along it. */
+    direction?: 'right' | 'down';
+    /**
+     * Keep fans on the sides facing their other ends, off far sides, and a full standoff away
+     * from their own end boxes. On unless false.
+     */
+    facing?: boolean;
+    /**
+     * Keep lines out of a group's title band, except a line straight into or out of a member's
+     * top. On unless false.
+     */
+    titleBands?: boolean;
+    /** Search each route near its two boxes first, and the whole grid only when that fails. On unless false. */
+    window?: boolean;
+    /** Even out ports, fans and corridors after routing. On unless false. */
+    tidy?: boolean;
+    /**
+     * In the tidy pass, straighten steps under 12px by sliding a run (and its port, or through a
+     * fold lane's waypoints) onto the next. On unless false.
+     */
+    jogs?: boolean;
+}
+export type Axis = 'x' | 'y';
+/** Which end of an edge: its source or its target. */
+export type End = 'from' | 'to';
+export type Flow = 'right' | 'down';
+/** A shape the router ends lines on: a node, or a collapsed group drawn as a box. */
+export type Box = Rect & {
+    id: string;
+    parentId?: string;
+    shape?: ShapeKind;
+    frame?: boolean;
+};
+/**
+ * A rectangle no line may enter. `across` lets an upright line cross it but none run along it;
+ * with `gates`, only at those x coordinates.
+ */
+export type Obstacle = Rect & {
+    id?: string;
+    across?: boolean;
+    gates?: number[];
+};
+/** A box or group border that lines should keep `band` away from, at a cost instead of a wall. */
+export type NearBox = Rect & {
+    id: string;
+    band: number;
+    /** A group border: it counts from both sides. */
+    border?: boolean;
+    weight?: number;
+};
+/** A side and offset the repair pass fixes at one end of an edge. */
+export interface Pin {
+    side: Side;
+    offset: number;
+}
+/** An edge as routed: the input edge with a config, and the repair pass's pins. */
+export type RouteEdge = RouteEdgeInput & {
+    pin?: Partial<Record<End, Pin>>;
+};
+/** One choice of sides and ports for an edge, with its stubs and the obstacles it sees. */
+export interface Candidate {
+    /** Source and target sides. */
+    fs: Side;
+    ts: Side;
+    /** Port offsets along those sides. */
+    fo: number;
+    toff: number;
+    start: Point;
+    end: Point;
+    /** Where the stubs out of each port end. */
+    as: Point;
+    bs: Point;
+    obs: Obstacle[];
+    /** A lower bound on the route's score, to order the grid searches. */
+    lower: number;
+    /** The fan-out cost of the side pair, worked out once. */
+    fanout?: number;
+}
+export type { EdgeLayout, Point, Rect, RoutingSettings, ShapeKind, Side };