@weasel-js/diagram 1.11.0 → 1.12.0

package/dist/layout.entry-B-jJMc50.d.ts

@@ -0,0 +1,617 @@
+import { m as Bounds, b as PortSpec, g as Port, N as GroupInset, f as DiagramNode, M as MeasureRowText, X as RowBox, Z as RowPortBox, B as BodySpec, K as GraphNode, i as DiagramNodeReader, h as DiagramNodeLike, c as DiagramLabel, E as EdgeHop, l as LabelSpot, e as LayoutOptions, G as Graph, n as LayoutResult, d as LayoutFn, L as LayoutPorts, O as Outline } from './types-M_ccNAlk.js';
+import { Vec2, PoseDescriptor, Path } from '@weasel-js/core/math';
+import { SimulationNode, createSimulation } from '@weasel-js/simulation';
+
+/**
+ * Perimeter port labels: where the text naming a port is drawn, and how far
+ * past its node that reaches.
+ *
+ * A label sits outside the node, on the port's own face, and to one side of
+ * the line the port's wire leaves along, so the wire does not run through it.
+ * A port inside a row draws its label inside the box instead; that is a
+ * `ports` row's job, not this module's.
+ */
+
+/** Between a port and the near sides of its label, in world units. */
+declare const PORT_LABEL_GAP = 4;
+/**
+ * Where a label `size` big goes for a port at `point` facing `normal`.
+ *
+ * A port on a left or right face gets its label outside that face, above its
+ * wire; one on a top or bottom face, outside that face, right of its wire; a
+ * corner port, off the corner. A port with no direction gets it centered
+ * above.
+ */
+declare function portLabelBox(port: {
+    point: Vec2;
+    normal: Vec2 | null;
+}, size: {
+    width: number;
+    height: number;
+}, gap?: number): Bounds;
+/** Where a built body's perimeter port label sits, as `buildBody`'s
+ *  `portLabel` is handed it. */
+interface PerimeterPortLabelBox extends Bounds {
+    port: PortSpec;
+    side: 'outside';
+}
+/** A labeled port, resolved, and the box its label is drawn in. */
+interface PortLabelPlacement {
+    port: Port & {
+        label: string;
+    };
+    box: Bounds;
+}
+/** Every labeled port of `trait` resolved against `bounds`, with its label's
+ *  box. `size` measures one label. */
+declare function portLabelsOf(trait: DiagramNode, bounds: Bounds, size: (text: string) => {
+    width: number;
+    height: number;
+}): PortLabelPlacement[];
+/** How far `boxes` reach past `bounds` on each side; `undefined` for none. */
+declare function marginOf(bounds: Bounds, boxes: readonly Bounds[]): GroupInset | undefined;
+
+/** What {@link buildBody} emits: the `AddNodeSpec` fields it fills in. Named
+ *  structurally rather than imported so a consumer whose scene is typed
+ *  differently can still spread one. */
+interface BodyNodeSpec<TData, TLayer extends string, TPose> {
+    kind: 'container' | 'leaf';
+    layer: TLayer;
+    pose: TPose;
+    data: TData;
+    id?: string;
+    parent?: string;
+    /** Set on the container to {@link clipNothing}: a perimeter port label sits
+     *  outside the body, and a container clips its children to its outline. */
+    clipFromPose?: () => null;
+    /** Set `false` on every leaf the builder emits: the innermost hit wins, so a
+     *  row that answers a press is a body that cannot be dragged. */
+    pickable?: boolean;
+}
+/** What a built body's rows are handed to, one call per row.
+ *
+ *  `text` is the row's content already formatted — a `label`'s own text, or a
+ *  `field`'s `"label: value"` — so the common case needs no discrimination.
+ *  Return `null` for a row the consumer paints itself; `ports` and `slot` rows
+ *  arrive with `text` empty and are the usual ones to decline. */
+type RowNodeData<TData> = (text: string, box: RowBox) => TData | null;
+/** Options for {@link buildBody}: the layer and data of each node it emits.
+ *  Without `measure`, rows are sized from a fallback line height rather than
+ *  their text. */
+interface BuildBodyOptions<TData, TLayer extends string, TPose extends Bounds> {
+    layer: TLayer;
+    /** The container's id. Edges name it, so pass one for anything an edge or a
+     *  layout `pin` will refer to. */
+    id?: string;
+    measure?: MeasureRowText;
+    /** The container's own data, given the trait the builder computed and the
+     *  pose it was computed against. */
+    body: (trait: DiagramNode, pose: TPose) => TData;
+    /** One row's data, or `null` to leave that row undrawn. */
+    row: RowNodeData<TData>;
+    /** One port's label — a row port's or a perimeter port's — or `null` to
+     *  leave it undrawn. Ports with no label are never offered. Omit to draw none. */
+    portLabel?: (text: string, box: RowPortBox | PerimeterPortLabelBox) => TData | null;
+}
+/**
+ * The scene nodes a built body is: one container carrying the trait, and one
+ * leaf per row that wants drawing.
+ *
+ * Rows are ordinary scene nodes rather than something this package paints, so
+ * the kit's own text painter draws them and text editing, styling, and
+ * selection work on them unchanged. The returned pose is `at` grown to fit the
+ * body, never shrunk.
+ */
+declare function buildBody<TData, TLayer extends string, TPose extends Bounds>(spec: BodySpec, at: TPose, opts: BuildBodyOptions<TData, TLayer, TPose>): {
+    pose: TPose;
+    specs: BodyNodeSpec<TData, TLayer, TPose>[];
+};
+
+/** `node` as layout sees it: bounds grown by its margin, ports where they were. */
+declare function footprintNode(node: GraphNode): GraphNode;
+
+/**
+ * Where a node's ports are, in world coordinates.
+ *
+ * A port is placed in the node's **unrotated** bounds, then carried through
+ * the pose's rotation — the same pivot every other kit reader uses, the AABB
+ * center. Bounds come from the pose descriptor rather than from `pose.width`
+ * and friends, so a node whose pose is a path, an ellipse or anything else a
+ * consumer wired is connectable on the same terms as a rect.
+ */
+
+/** The eight anchors almost everything wants, named the way a compass is. */
+declare const COMPASS: {
+    readonly nw: {
+        readonly u: 0;
+        readonly v: 0;
+    };
+    readonly n: {
+        readonly u: 0.5;
+        readonly v: 0;
+    };
+    readonly ne: {
+        readonly u: 1;
+        readonly v: 0;
+    };
+    readonly e: {
+        readonly u: 1;
+        readonly v: 0.5;
+    };
+    readonly se: {
+        readonly u: 1;
+        readonly v: 1;
+    };
+    readonly s: {
+        readonly u: 0.5;
+        readonly v: 1;
+    };
+    readonly sw: {
+        readonly u: 0;
+        readonly v: 1;
+    };
+    readonly w: {
+        readonly u: 0;
+        readonly v: 0.5;
+    };
+};
+/**
+ * What a node carrying no `ports` gets: the four edge midpoints of its own
+ * bounds. Every node has bounds, so every node is connectable without saying
+ * anything.
+ */
+declare const DEFAULT_PORTS: readonly PortSpec[];
+/** How ports are resolved against a node: its bounds, and its trait. */
+interface PortsOptions<TPose> {
+    /** Reads the AABB a port is placed in, and the node's rotation. Defaults to
+     *  the kit's `AUTO_POSE_DESCRIPTOR`, which handles rect and path poses. */
+    geometry?: PoseDescriptor<TPose>;
+    /** How the `DiagramNode` trait is read off a node. */
+    read?: DiagramNodeReader;
+}
+/**
+ * Every port on `node`, resolved against `pose`.
+ *
+ * Pass the pose the node is **painted** at — `effectivePose(scene, node)` —
+ * not `node.pose`. A port that answers from the document pose while the node
+ * is mid-drag puts an edge somewhere the user can see the node is not.
+ */
+declare function portsOf<TPose>(node: DiagramNodeLike, pose: TPose, opts?: PortsOptions<TPose>): Port[];
+/** One named port, or `undefined` when the node has no such port. */
+declare function portOf<TPose>(node: DiagramNodeLike, pose: TPose, portId: string, opts?: PortsOptions<TPose>): Port | undefined;
+/** One named port at each place it may sit: at `at` first, then at each of
+ *  its `sites`. Empty when the node has no such port. */
+declare function portSitesOf<TPose>(node: DiagramNodeLike, pose: TPose, portId: string, opts?: PortsOptions<TPose>): Port[];
+
+/**
+ * What the obstacle-avoiding router reads and answers. Plain data: it knows
+ * nothing of scenes, so a host with its own nodes routes with it directly.
+ */
+
+/** An axis-aligned box in world units. */
+type Box = Bounds;
+/** A place a connector's end may leave or arrive: a port's point and the
+ *  unit direction it faces away from its shape. */
+interface AvoidPort {
+    point: Vec2;
+    normal: Vec2;
+}
+/** One end of a connector: the shape it is on, and the ports it may use.
+ *  An end glued to a shape rather than to one port offers every port. */
+interface AvoidEnd {
+    node: string;
+    ports: readonly AvoidPort[];
+}
+/** A connector to route. */
+interface AvoidEdge {
+    id: string;
+    from: AvoidEnd;
+    to: AvoidEnd;
+    /** The author's stops between the ends, passed in order. */
+    waypoints?: readonly Vec2[];
+    /** The route it holds now: the bends between its ends. */
+    route?: readonly Vec2[];
+    /** Its label, which every other connector routes around. The router
+     *  stations it on this connector's route as `labelCenter` does. */
+    label?: AvoidLabel;
+}
+/** A connector's label as the router reads it: where along the route it
+ *  sits, and how big it is. */
+interface AvoidLabel {
+    id: string;
+    placement: DiagramLabel;
+    size: {
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Something connectors route around.
+ *
+ * - `shape` blocks every connector beyond its own port stubs.
+ * - `region` (a container or pool) blocks a connector only when neither of
+ *   its ends is one of `members`.
+ * - `label` blocks every connector but `edge`, the one it labels.
+ */
+interface AvoidObstacle {
+    id: string;
+    box: Box;
+    kind: 'shape' | 'region' | 'label';
+    /** For a region: the shapes inside it, at any depth. */
+    members?: ReadonlySet<string>;
+    /** For a label: the connector it labels. */
+    edge?: string;
+}
+/** What one update reads: every obstacle and every connector there is now. */
+interface AvoidInput {
+    obstacles: readonly AvoidObstacle[];
+    edges: readonly AvoidEdge[];
+}
+/** How the router routes. Every field has a default. */
+interface AvoidOptions {
+    /** How far a route keeps from every obstacle, in world units. Default 10. */
+    clearance?: number;
+    /** Cost of one turn, in world units of length. Default 40. */
+    bendPenalty?: number;
+    /** Cost of crossing another connector's route. Default 20. */
+    crossPenalty?: number;
+    /** Distance between parallel runs after nudging. Default 8. */
+    spacing?: number;
+    /** How far past a leg's stops the search first looks; it doubles while no
+     *  path fits. Default 100. */
+    margin?: number;
+    /** How far a route keeps from another connector's label. Default 4. */
+    labelClearance?: number;
+}
+/** {@link AvoidOptions} with every default filled in. */
+type ResolvedAvoidOptions = Required<AvoidOptions>;
+/** The defaults behind {@link AvoidOptions}. */
+declare const AVOID_DEFAULTS: ResolvedAvoidOptions;
+
+/**
+ * The incremental router: it holds the obstacles it last committed and the
+ * routes it last made, and each update reroutes only what changed.
+ */
+
+/** How one {@link AvoidRouter.update} runs. */
+interface AvoidUpdateOptions {
+    /** A drag frame: route against the committed obstacles without replacing
+     *  them, with no crossing penalty and no nudging. */
+    preview?: boolean;
+    /** Milliseconds a preview may spend. The connectors it does not reach keep
+     *  the route the last preview gave them. Default no limit. */
+    budgetMs?: number;
+}
+/** Each rerouted connector's new route, the bends between its ends, or null
+ *  where no path was found and the connector falls back to `orthogonal`. */
+type AvoidRoutes = Map<string, Vec2[] | null>;
+/** An obstacle-avoiding router that remembers what it last routed. */
+interface AvoidRouter {
+    /** Take `input` as already routed: its obstacles as committed and each
+     *  connector's `route` as its own, routing nothing. */
+    seed(input: AvoidInput): void;
+    /** Reroute what changed since the last commit, and commit `input` unless
+     *  this is a preview. Answers only the connectors it rerouted, or moved
+     *  while spreading a channel they share. */
+    update(input: AvoidInput, opts?: AvoidUpdateOptions): AvoidRoutes;
+}
+/** A router with `options` over the defaults. */
+declare function createAvoidRouter(options?: AvoidOptions): AvoidRouter;
+
+/**
+ * Whether a stored route still fits its ends: it leaves along the departing
+ * port's facing, arrives against the receiving one's, and passes every
+ * authored waypoint in order. One that does not was made for ends that have
+ * since moved.
+ */
+
+/** An end as the check reads it: where it is and which way it faces. */
+interface HeldEnd {
+    point: Vec2;
+    normal: Vec2 | null;
+}
+/** Whether `route`, the bends between `from` and `to`, still fits them and passes `waypoints` in order. */
+declare function routeHolds(from: HeldEnd, to: HeldEnd, waypoints: readonly Vec2[], route: readonly Vec2[]): boolean;
+
+/**
+ * Where connectors cross, as the hops the upper one of each pair makes over
+ * the lower. Arithmetic on polylines: nothing here reads a scene.
+ */
+
+/**
+ * The hops each connector makes where it crosses one drawn before it.
+ *
+ * `polylines` holds each connector's route by id; `order` is render order, and
+ * of two crossing connectors the later one hops. Only proper crossings count:
+ * a touch at an end and a collinear overlap are not, nor is a crossing within
+ * `2r` of either connector's ends, nor one within `r` of a bend of the
+ * hopping connector, where its half circle would not fit. Hops on one segment
+ * closer than `2r` merge into one longer hop.
+ *
+ * Answers every connector of `only` (default: all of `order`), with no hops
+ * as an empty list.
+ */
+declare function edgeHops(polylines: ReadonlyMap<string, readonly Vec2[]>, order: readonly string[], r: number, only?: ReadonlySet<string>): Map<string, EdgeHop[]>;
+
+/**
+ * Where a label stands on a route: the arithmetic `labelDerivePose` runs,
+ * kept free of the scene so the router and the placer can station a label
+ * without one.
+ */
+
+/** Where the center of a label `size` big sits along `whole`, on its first
+ *  subpath, at the station placement chose for it when it has one; `null`
+ *  for a path with no points. */
+declare function labelCenter(whole: Path, label: DiagramLabel, size: {
+    width: number;
+    height: number;
+}): Vec2 | null;
+
+/**
+ * Label placement as arithmetic: shapes, routes, and labels in, the station
+ * each moving label settles at out. A label that something covers slides
+ * along its own route, or flips to the other side of it, to the nearest
+ * clear spot.
+ */
+
+/** A connector's route as placement reads it: every point it runs through,
+ *  its ends included. */
+interface PlaceRoute {
+    id: string;
+    points: readonly Vec2[];
+    /** Further runs it draws, apart from `points`: the far stub of a connector
+     *  split across pages. Other labels keep off them; its own stands on `points`. */
+    more?: readonly (readonly Vec2[])[];
+}
+/** A label to place, or to steer the others off. */
+interface PlaceLabel {
+    id: string;
+    /** The connector it sits on: a {@link PlaceRoute}'s id. */
+    edge: string;
+    /** Its trait. `at` and `offset` are the preferred station; `placed`, where
+     *  it stands now; `dodge: false`, never move it. */
+    placement: DiagramLabel;
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Whether it may move now. Default true. One that may not is an
+     *  obstacle where it stands. */
+    moving?: boolean;
+}
+/** What one placement reads. */
+interface PlaceLabelsInput {
+    shapes: readonly {
+        id: string;
+        box: Bounds;
+    }[];
+    routes: readonly PlaceRoute[];
+    labels: readonly PlaceLabel[];
+}
+/** How labels are placed. Every field has a default. */
+interface PlaceLabelsOptions {
+    /** How far a label keeps from what it dodges, in world units. Default 2. */
+    gap?: number;
+    /** Stations tried each way along the route. Default 4. */
+    tries?: number;
+    /** Room between one station and the next, beyond the label's width. Default 8. */
+    spacing?: number;
+}
+/** Where a moving label settles: a station off its preference, or null when
+ *  its preferred station is the best there is. */
+type LabelPlacements = Map<string, LabelSpot | null>;
+/**
+ * Where each moving label settles. Each tries its preferred station, then
+ * the stations either side of it along its route and across the line, and
+ * keeps the cheapest: area over shapes ×1000, area over labels already
+ * placed ×100, other routes it covers ×10, plus how far it moved. Labels
+ * that are not moving are placed already; moving ones go in id order, each
+ * an obstacle for the next, so the answer depends on nothing else.
+ */
+declare function placeLabels(input: PlaceLabelsInput, opts?: PlaceLabelsOptions): LabelPlacements;
+
+/**
+ * `force` — relaxation, for a graph with no direction to read it in.
+ *
+ * Seeded from where the nodes already are rather than from a fresh random
+ * scatter: an author who has arranged half a diagram gets that arrangement
+ * relaxed, not replaced. There is no RNG in it at all — two coincident nodes
+ * are separated along a golden-angle spiral keyed to their index.
+ *
+ * The forces are the naive O(n²) kind — right for tens to hundreds of nodes,
+ * wrong for a 10k-node graph.
+ *
+ * **This is the one layout that is not idempotent.** A relaxation re-run from
+ * its own output keeps relaxing; `direction` means nothing to it. Pins and the
+ * `tolerance` option are what keep a second pass from scrambling a settled
+ * diagram.
+ */
+
+/** Options for {@link force} and {@link forceRelaxation}. `direction` is
+ *  ignored. */
+interface ForceOptions extends LayoutOptions {
+    /** Ticks to run. Default 300 — one full cooling schedule. */
+    iterations?: number;
+    /** Rest length of an edge, in world units. Default 160. */
+    linkDistance?: number;
+    /** How hard an edge pulls, 0..1. Default 0.35. */
+    linkStrength?: number;
+    /** Pairwise repulsion. Negative repels; default -3000. */
+    charge?: number;
+    /** How hard the graph is held around its own centroid. Default 0.02. */
+    gravity?: number;
+    /** Clear space kept between two boxes, in world units. Default 24. */
+    padding?: number;
+    /** How hard a group draws its members together, 0..1. Default 0.2. */
+    groupStrength?: number;
+}
+/** One node as the relaxation sees it: a simulation point centered on the
+ *  node's box. */
+interface ForceBody extends SimulationNode {
+    id: string;
+    /** Half the node's box, so separation can work on the shape the author sees
+     *  rather than on a point. */
+    hw: number;
+    hh: number;
+}
+/**
+ * The bodies and the force list, wound up and ready to tick.
+ */
+interface ForceRelaxation {
+    bodies: ForceBody[];
+    byId: Map<string, ForceBody>;
+    /** Ids the caller must not move: declared pins, held as `fx`/`fy`. */
+    pinned: ReadonlySet<string>;
+    sim: ReturnType<typeof createSimulation<ForceBody>>;
+    /** Where a body's node's top-left sits, given the body's center. */
+    placed(): Map<string, {
+        x: number;
+        y: number;
+    }>;
+}
+/** Wind up a relaxation of `graph` without ticking it: bodies seeded from
+ *  where the nodes are, pins held fixed. Tick `sim` yourself and read the
+ *  top-lefts from `placed()`. */
+declare function forceRelaxation(graph: Graph, opts?: ForceOptions): ForceRelaxation;
+/** The force-directed layout. Unlike the others it is not idempotent: a
+ *  re-run keeps relaxing, so pins and `tolerance` are what hold a settled
+ *  diagram still. */
+declare const force: (graph: Graph, opts?: ForceOptions) => LayoutResult;
+
+/** The chain layout: the nodes `opts.chain` names (or the longest path) on
+ *  one line in order, and every other node hung beside the chain node it is
+ *  fewest edges from, on the `opts.chainSide` side. Its `plan` also routes
+ *  each edge between a chain node and a node hung beside it through a track
+ *  of its own, so a fan of them into one node does not cross itself. */
+declare const chain: LayoutFn;
+
+/** Which edges a layered layout turns around so that no cycle is left. */
+
+/** Edge ids that close a cycle, found by a depth-first walk in graph order.
+ *  Which edges get named depends only on the node order, so it is the same
+ *  every run. A self-loop is not one: it points neither way. */
+declare function backEdges(graph: Graph): Set<string>;
+/** Longest-path rank per node: one past its deepest predecessor, ignoring
+ *  `back`. Every node with no predecessor is rank 0. */
+declare function ranksOf(graph: Graph, back: ReadonlySet<string>): Map<string, number>;
+
+/**
+ * The layered layout's whole answer: where each node goes, and where each long
+ * edge runs, read off where its placeholders were placed.
+ */
+
+/** What {@link layeredPlan} works out. */
+interface LayeredPlan {
+    /** The new top-left of every node that moves, as `layered` returns it. */
+    moves: LayoutResult;
+    /** Each node's rank. */
+    ranks: ReadonlyMap<string, number>;
+    /** Ids of the graph edges laid out pointing the other way. */
+    back: ReadonlySet<string>;
+    /** For each edge spanning ranks, keyed by the edge's id as drawn: points
+     *  from its `from` end to its `to` end, two per rank it crosses, where it
+     *  enters and leaves that rank. */
+    waypoints: ReadonlyMap<string, readonly Vec2[]>;
+    /** For each labeled edge given room, keyed by the edge's id as drawn: the
+     *  point on its route that room is beside, as a `DiagramLabel`'s
+     *  `{ near }` reads it. */
+    labels: ReadonlyMap<string, Vec2>;
+    /** For each edge running between ranks, keyed by the edge's id as drawn:
+     *  the compass ports facing the way it runs (see `layeredPorts`). */
+    ports: ReadonlyMap<string, LayoutPorts>;
+    /** Pinned nodes after the first that the layout could not be built
+     *  around: covering one with its rank's band would bring that band nearer
+     *  another pinned rank's than the bands between them allow with every gap
+     *  at a quarter of `rankGap` beyond its groups' insets, or would put a
+     *  group's box over a pin it does not hold. They stay put, and the rest is
+     *  laid out around the slot each would have had. */
+    unheld: ReadonlySet<string>;
+}
+/** The layered layout, with the ranks and edge routes it settled on. */
+declare function layeredPlan(graph: Graph, opts?: LayoutOptions): LayeredPlan;
+
+/** Ranking by network simplex (Gansner, Koutsofios, North and Vo, 1993: "A
+ *  Technique for Drawing Directed Graphs", the ranking Graphviz dot uses). */
+
+/**
+ * Each node's rank, chosen to make the total edge length as short as it can:
+ * the sum over edges of `rank(to) - rank(from)`, with every edge at least one
+ * rank long and every edge weighing the same.
+ *
+ * An edge in `back` counts as running the other way, so it is ranked and kept
+ * forward like any other; a self-loop is ignored; parallel edges each count.
+ * Each connected component is ranked on its own and starts at rank 0.
+ *
+ * Starts from the longest-path ranking and improves it by network simplex,
+ * stopping after a number of rounds proportional to the edge count. Every
+ * round leaves a valid ranking, so the answer is valid even when the cap is
+ * hit. Ties break by graph order — node index, then edge index — so the same
+ * graph always ranks the same.
+ *
+ * If `back` leaves a cycle, no valid ranking exists; that component keeps its
+ * longest-path start, which `ranksOf` would also give.
+ */
+declare function ranksByLength(graph: Graph, back: ReadonlySet<string>): Map<string, number>;
+
+/**
+ * `layered` — ranks running one way, nodes running across.
+ *
+ * The flowchart / pipeline layout: an edge points from one rank to the next.
+ * The steps live in `./layered/`: edges closing a cycle are turned around
+ * (`cycles`), ranks are chosen to keep edges short (`rank`), an edge spanning
+ * ranks gets a placeholder in each rank it crosses (`expand`), each rank is
+ * ordered (`order`), and nodes are lined up with their neighbors (`place`).
+ * `plan` puts it together.
+ *
+ * Under `order: 'seeded'` (the default) each rank keeps the order its nodes
+ * and edges already sit in, so a re-run moves nothing. `order: 'barycenter'`
+ * reorders to cut crossings. Either way, a placeholder's position routes its
+ * long edge, which `layered.plan` hands back.
+ */
+
+/** The ranked layout: each edge points one rank further along `direction`.
+ *  Under `order: 'seeded'` a re-run moves nothing; `order: 'barycenter'`
+ *  reorders ranks to cut crossings. */
+declare const layered: LayoutFn;
+
+/** A graph read as trees: its roots, each node's children in order, and each node's depth. */
+interface Forest {
+    roots: GraphNode[];
+    children: Map<string, GraphNode[]>;
+    depth: Map<string, number>;
+}
+/** The forest a depth-first walk in graph order finds. Exported because "which
+ *  node ended up whose child" is the question anyone debugging a tree layout
+ *  asks first. */
+declare function forestOf(graph: Graph, crossAxis: 'x' | 'y'): Forest;
+/** The hierarchy layout: each parent centered over its children's block, one
+ *  rank per depth. A graph that is not a tree lays out as the forest
+ *  {@link forestOf} reads from it. */
+declare const tree: LayoutFn;
+
+/** The outline as a closed polyline: `[x0, y0, x1, y1, …]`. */
+declare function outlinePolyline(outline: Outline, bounds: Bounds): number[];
+/**
+ * Where the ray from `center` through `point` last crosses `poly`, or `null`
+ * when it never does.
+ *
+ * The *last* crossing rather than the first: a concave outline can be crossed
+ * more than once, and the far side is the boundary an edge should attach to.
+ */
+declare function rayHit(poly: readonly number[], center: {
+    x: number;
+    y: number;
+}, point: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+} | null;
+/**
+ * Every port moved onto `outline`. A port the ray misses — one at the node's
+ * dead center, with no direction to cast along — is left where it was.
+ */
+declare function portsOnOutline(ports: readonly Port[], outline: Outline, bounds: Bounds): Port[];
+
+export { rayHit as $, type AvoidInput as A, type BodyNodeSpec as B, COMPASS as C, DEFAULT_PORTS as D, edgeHops as E, type ForceOptions as F, footprintNode as G, force as H, forceRelaxation as I, forestOf as J, labelCenter as K, type LabelPlacements as L, layered as M, layeredPlan as N, marginOf as O, type PortsOptions as P, outlinePolyline as Q, type RowNodeData as R, placeLabels as S, portLabelBox as T, portLabelsOf as U, portOf as V, portSitesOf as W, portsOf as X, portsOnOutline as Y, ranksByLength as Z, ranksOf as _, type AvoidRouter as a, routeHolds as a0, tree as a1, type AvoidOptions as b, type AvoidRoutes as c, type PlaceLabelsOptions as d, AVOID_DEFAULTS as e, type AvoidEdge as f, type AvoidEnd as g, type AvoidLabel as h, type AvoidObstacle as i, type AvoidPort as j, type AvoidUpdateOptions as k, type BuildBodyOptions as l, type ForceBody as m, type ForceRelaxation as n, type Forest as o, type LayeredPlan as p, PORT_LABEL_GAP as q, type PerimeterPortLabelBox as r, type PlaceLabel as s, type PlaceLabelsInput as t, type PlaceRoute as u, type PortLabelPlacement as v, backEdges as w, buildBody as x, chain as y, createAvoidRouter as z };

package/dist/layout.js

@@ -1,3 +1,5 @@
-export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, PORT_LABEL_GAP, anchorOffset, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, chain, contentBox, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, layered, layeredPlan, layoutBody, layoutRowPorts, marginOf, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, planOf, plannerPlan, portLabelBox, portOf, portSitesOf, portsOf, portsOnOutline, ranksByLength, ranksOf, rayHit, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-NUMMW5BI.js';
+import './chunk-WDIE35AK.js';
+export { AVOID_DEFAULTS, DEFAULT_HOP_SIZE, HOPS_DOC_KEY, createAvoidRouter, edgeHops, placeLabels } from './chunk-GA4BX7SH.js';
+export { COMPASS, DEFAULT_NODE_GAP, DEFAULT_PORTS, DEFAULT_RANK_GAP, PORT_LABEL_GAP, anchorOffset, axesFor, backEdges, bodyOutline, boxForContent, buildBody, canvasMeasure, chain, contentBox, extent, footprintNode, force, forceRelaxation, forestOf, graphOrder, labelCenter, layered, layeredPlan, layoutBody, layoutRowPorts, marginOf, measureBody, outlinePath, outlinePolyline, packAcross, pinnedSet, planOf, plannerPlan, portLabelBox, portOf, portSitesOf, portsOf, portsOnOutline, ranksByLength, ranksOf, rayHit, routeHolds, seededOrder, settle, sizeToBody, translated, tree, untilSettled } from './chunk-R2XB6D32.js';
 //# sourceMappingURL=layout.js.map
 //# sourceMappingURL=layout.js.map