@draftably/markdown 0.2.3 → 0.2.4

package/dist/mermaid.js

@@ -61,7 +61,7 @@ async function S() {
   globalThis.fetch = async () => {
     throw Error("Mermaid resource loading is disabled.");
   };
-  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-DcseMRou.js"), r = new i("<!doctype html><html><body></body></html>", {
+  const { JSDOM: i } = await import("jsdom"), { createMermaidFlowParser: s, makePlainLabel: e } = await import("./chunks/mermaid-facade-BoLWBerE.js"), { importMermaidFlow: t } = await import("./chunks/mermaid-importer-S5o6DWXk.js"), r = new i("<!doctype html><html><body></body></html>", {
     url: "https://import.invalid/"
   });
   Object.assign(globalThis, {

package/dist/types/src/dsl/compile.d.ts

@@ -49,6 +49,8 @@ export interface SceneEdge extends ModelEdge {
     plan?: Planned;
     /** A sequence message: the height of its row; it is drawn straight between lifelines there. */
     row?: number;
+    /** A message between distant lanes: the middle of the gap its label sits in. */
+    labelX?: number;
 }
 export interface Scene {
     model: Model;

package/dist/types/src/dsl/sequence-layout.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The arithmetic of a sequence diagram's layout, apart from the scene it is applied to: where a
+ * label that spans several lanes sits, where each lane stands, and how tall each phase is.
+ * `sequenced` in `compile.ts` measures the text and calls these.
+ */
+/** A lower bound on a lane's centre: at least `room` past the centre of lane `from`. */
+export type Hold = {
+    from: number;
+    room: number;
+};
+/**
+ * The gap a distant message's label sits in, so it crosses no lifeline between its two ends.
+ * `base` holds the lane centres that the headers alone give. The choice prefers a gap inside one
+ * band, so the label covers no band's border, then a gap that already has room, then the gap
+ * nearest the middle of the message, then the left one. Returns the left lane of the gap.
+ */
+export declare function labelSlot(base: number[], a: number, b: number, room: number, across: (lane: number) => boolean): number;
+/**
+ * Lane centres from left to right: each lane takes the header gap from its neighbour, or what
+ * holds it away from an earlier lane, if that is more.
+ */
+export declare function laneCentres(first: number, gaps: number[], holds: Hold[][]): number[];
+/** What one event draws round its row: how far above it and how far below. */
+export type EventInk = {
+    id: string;
+    /** The phase that lists the event, if one does. */
+    phase?: string;
+    /** Height of the label above the line; 0 with no label or for a self-message. */
+    label: number;
+    /** Ink above and below the row. */
+    above: number;
+    below: number;
+    /** A self-message or a local action: the row after it must clear its ink. */
+    tall: boolean;
+    /** How far the event runs on down its lifeline, which the next row starts from. */
+    drop: number;
+};
+export type RowRules = {
+    /** Least distance between two rows. */
+    row: number;
+    /** Room between a tall event's ink and the next event's ink. */
+    clear: number;
+    /** Room between a phase band's edge and the ink inside it. */
+    pad: number;
+    /** Room between two phase bands. */
+    gap: number;
+};
+/**
+ * Rows from top to bottom, starting under the headers at `top`. A phase is one block: its band
+ * starts `gap` under what came before, holds its events with `pad` round them, and is at least
+ * as tall as its title needs. Events outside every phase keep the plain row rule.
+ */
+export declare function eventRows(events: EventInk[], top: number, titleHeight: (phase: string) => number, rules: RowRules): {
+    rows: Map<string, number>;
+    bands: Map<string, {
+        y: number;
+        h: number;
+    }>;
+    end: number;
+};
+/** An event as activation bars read it: who sends to whom, its kind, and what it answers. */
+export type SequenceEvent = {
+    id: string;
+    source: string;
+    target: string;
+    message?: string;
+    replyTo?: string;
+};
+/**
+ * A stretch in which a participant is at work on a call: from the event at index `start` to
+ * the one at `end`, or a short stub when `end` is unset. `level` is 0, or more when the
+ * participant took the call while another of its bars was open.
+ */
+export type ActivationSpan = {
+    lane: string;
+    call: string;
+    start: number;
+    end?: number;
+    level: number;
+};
+/**
+ * The activation bars of a sequence, read from its calls and their replies. A bar opens where a
+ * participant receives a `call` from another and closes at the last reply that answers that
+ * call. A call with no reply closes at the participant's next message to another, and without
+ * one it is a stub. A call a participant sends to itself opens no bar.
+ */
+export declare function activationSpans(events: SequenceEvent[]): ActivationSpan[];

package/dist/types/src/dsl/syntax.d.ts

@@ -6,7 +6,7 @@
  * keeps every comment and unrelated statement.
  */
 import { type DiagramAppearance, type Shade } from '../model/appearance';
-import { type EndMarker } from '../model/markers';
+import { type EndMarker, type MessageKind } from '../model/markers';
 import type { Status } from '../model/status';
 import type { ColorKey, LayoutAlgorithmId, LayoutSettings, PortSide, RoutingSettings, ShapeKind } from '../model/types';
 export declare class DslError extends Error {
@@ -131,9 +131,13 @@ export interface ModelEdge {
     tail?: EndMarker;
     /** `constraint=false`: drawn and routed, but layout doesn't rank or order by it. */
     constraint?: false;
+    /** Sequence diagrams: `message=`, or `action` for an `action` line. */
+    message?: MessageKind;
+    /** `answers=`: the earlier message a reply answers. */
+    replyTo?: string;
     line: number;
 }
-/** A layout engine run cold over a scope's subtree; see `src/engines/layout-engine.js`. */
+/** A layout engine run cold over a scope's subtree; see `src/engines/layout-engine.ts`. */
 export interface EngineRecipe {
     algorithm: LayoutAlgorithmId;
     params: Partial<LayoutSettings>;
@@ -160,6 +164,8 @@ export interface ModelLayout {
     /** With `unit`: the width of one unit, and whether unit numbers run above the first row. */
     unitWidth?: number;
     ruler?: boolean;
+    /** `sequence` only: draw a bar on a participant's lifeline while it is at work on a call. */
+    activations?: true;
     /** `flow` only: whether a long run of ranks folds into bands. Engines take `fold` as a param. */
     fold: 'auto' | 'never';
     /** Root only: the image shape to aim for; compile tries direction and folding to get closest. */

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

@@ -0,0 +1,36 @@
+import type { DiagramEdge, Direction } from '../../model/types.ts';
+import type { Scene } from './scene.ts';
+import type { Centres, Item, LayoutIntent, Point, Rect, Topology } from './types.ts';
+/** A link with an end outside the solve, or between two of its items: `a` and `b` are the items that own its ends. */
+export interface BoundaryLink extends DiagramEdge {
+    a: string | null;
+    b: string | null;
+}
+/** What one solve of one container's children shares with its force, separation and packing steps. */
+export interface Batch {
+    parentId: string | null;
+    direction: Direction;
+    items: Item[];
+    byId: Map<string, Item>;
+    t: Topology;
+    localIntent: LayoutIntent;
+    boundaryLinks: BoundaryLink[];
+    /** Hop counts, for the stress solve only. */
+    distances: Map<string, Map<string, number>> | null;
+    target: Centres | null;
+    /** The inside of the parent's frame, or null at the top level. */
+    container: Rect | null;
+    availableAspect: number;
+    /** Each item's centre when the solve began. */
+    origin: Centres;
+    anchor: number;
+    baseCenter: Point;
+    pairGap(a: Item, b: Item): number;
+    /** Copies the document's positions back onto the items. */
+    sync(): void;
+}
+/**
+ * Solves the children of one container: builds the target for the chosen algorithm, runs the
+ * force ticks, and keeps the best state by collisions first and energy second.
+ */
+export declare function arrange(scene: Scene, activeIds: string[], parentId: string | null, direction: Direction): Promise<void>;

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

@@ -0,0 +1,7 @@
+import type { Diagram } from '../../model/types.ts';
+import type { LayoutOptions, LayoutResult } from './types.ts';
+/**
+ * Lays out a copy of `input`. A pass moves boxes at most `maxMove` from where they are; a rebuild
+ * starts from a seed. Pins, fixed frames and the scope bound what may move.
+ */
+export declare function compute(input: Diagram, opts?: LayoutOptions): Promise<LayoutResult>;

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

@@ -0,0 +1,8 @@
+import type { Batch } from './arrange.ts';
+import type { Scene } from './scene.ts';
+/** The force on each item for one tick, by ID; `degree` is the weight of the links behind it. */
+export declare function tickForces(scene: Scene, batch: Batch): Map<string, {
+    x: number;
+    y: number;
+    degree: number;
+}>;

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

@@ -0,0 +1,10 @@
+import type { Centres, Item, Rect, Settings } from './types.ts';
+/** Items in ID order on a grid of even cells, near the wanted aspect. */
+export declare function seedGrid(items: Item[], s: Settings, aspect: number): Centres;
+/** The nearest free cell of a grid round the current centre, closest matches first. */
+export declare function gridTarget(items: Item[], s: Settings, aspect: number): Centres;
+/**
+ * Shifts a target onto the drawing: onto the container's corner, the mean of the fixed items, a
+ * fixed origin for a rebuild (`canonical`), or else the items' current centre.
+ */
+export declare function alignTarget(map: Centres, items: Item[], container: Rect | null, canonical?: boolean): Centres;

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

@@ -0,0 +1,14 @@
+import type { IntentPlacement, IntentRole } from '../../model/types.ts';
+import type { Centres, Item, LayoutIntent } from './types.ts';
+export type Hint = {
+    id: string;
+    placement: IntentPlacement;
+};
+/** The hints of an intent with their roles, in the order the intent holds them. */
+export declare const hintsOf: (intent: LayoutIntent) => Array<[IntentRole, Hint]>;
+/** Where in the drawing's box each placement puts a shape, as fractions of its free width and height. */
+export declare const placements: Record<IntentPlacement, [number, number]>;
+/** A checked start and end hint. Throws on an unknown shape, an unknown placement, or one shape in both roles. */
+export declare function normalizeIntent(raw?: unknown, validIds?: Set<string> | null): LayoutIntent;
+/** The centre each hinted item should reach, inside the items' current box. */
+export declare function hintTargets(items: Item[], intent: LayoutIntent): Centres;

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

@@ -0,0 +1,5 @@
+import type { Centres, Item, Settings, Topology } from './types.ts';
+/** Straight centre-to-centre crossings between a candidate placement's edges. */
+export declare function sketchCrossings(t: Topology, map: Centres): number;
+/** Ranks as columns (or rows), ordered by barycentre sweeps, folded into bands when that fits the aspect better. */
+export declare function layeredTarget(items: Item[], t: Topology, s: Settings, aspect: number): Centres;

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

@@ -0,0 +1,6 @@
+import type { Centres, Item, Settings, Topology } from './types.ts';
+/**
+ * The energy a solve lowers: hint and target errors, link lengths by algorithm, overlap area and
+ * forward links that run backwards. `compoundEnergy` adds the cross-boundary links of a compound solve.
+ */
+export declare function objective(items: Item[], t: Topology, s: Settings, distances: Map<string, Map<string, number>> | null, target: Centres | null, compoundEnergy: (() => number) | null): number;

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

@@ -0,0 +1,7 @@
+import type { Batch } from './arrange.ts';
+import type { Scene } from './scene.ts';
+/**
+ * After a rebuild that left overlaps inside a fixed frame: place the movable items one at a time
+ * at the free spot nearest their target, in up to four orders. Moves them only when one order fits.
+ */
+export declare function packIntoFrame(scene: Scene, batch: Batch, collisions: number): void;

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

@@ -0,0 +1,7 @@
+import type { Scene } from './scene.ts';
+import type { LayoutResult, LayoutScope } from './types.ts';
+/**
+ * Ends a run: holds each move to the pass limit and rounds it, rejects a pass that added
+ * overlaps, writes the settings back, and builds the report.
+ */
+export declare function finish(scene: Scene, scope: LayoutScope, started: number, authoredRootId: string): LayoutResult;

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

@@ -0,0 +1,53 @@
+import type { DiagramGroup, DiagramNode, Direction, NodeLayout } from '../../model/types.ts';
+import type { Diagram, LayoutMetrics, LayoutOptions, Settings, SolverStop, TraceFrame } from './types.ts';
+/** A shape or group ID, or nothing for the top level. */
+export type ParentId = string | null | undefined;
+/** Counters and findings that every solve of one layout run adds to. */
+export interface Run {
+    batchCount: number;
+    totalIterations: number;
+    /** Which hierarchy sweep is running; odd sweeps of a compound layout go top down. */
+    hierarchyPhase: number;
+    stops: SolverStop[];
+    warnings: Set<string>;
+    /** Containers whose children a rebuild has already placed from a seed. */
+    seeded: Set<string | null>;
+}
+/**
+ * One layout run's view of the document: the hierarchy, what is fixed or hidden, and the only
+ * ways a solve may move or measure boxes. `doc` is the copy the run changes; `original` keeps the
+ * geometry it started from.
+ */
+export declare function createScene(input: Diagram, doc: Diagram, s: Settings, opts: LayoutOptions): {
+    doc: Diagram;
+    original: Record<string, NodeLayout>;
+    nodeIndex: Map<string, number>;
+    s: Settings;
+    opts: LayoutOptions;
+    run: Run;
+    aspect: number;
+    intent: Partial<Record<import("../../model/types.ts").IntentRole, {
+        id: string;
+        placement: import("../../model/types.ts").IntentPlacement;
+    }>>;
+    compound: boolean;
+    globalTopology: import("./types.ts").Topology<import("../../model/types.ts").DiagramEdge>;
+    groups: Map<string, DiagramGroup>;
+    entities: Map<string, DiagramNode | DiagramGroup>;
+    pos: Record<string, NodeLayout>;
+    child: (id: ParentId) => (DiagramNode | DiagramGroup)[];
+    parent: (id: string) => string | undefined;
+    inheritedDirection: (id: ParentId) => Direction;
+    descend: (id: string) => string[];
+    branch: (id: ParentId) => boolean;
+    fixed: (id: string) => boolean;
+    visible: (id: string) => boolean;
+    padded: (id: string) => NodeLayout;
+    move: (id: string, dx: number, dy: number) => void;
+    resizeAuto: (id: string) => void;
+    metrics: () => LayoutMetrics;
+    before: LayoutMetrics;
+    trace: TraceFrame[];
+    captureTrace: (phase: string, force?: boolean) => void;
+};
+export type Scene = ReturnType<typeof createScene>;

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

@@ -0,0 +1,3 @@
+import type { Direction } from '../../model/types.ts';
+import type { Scene } from './scene.ts';
+export declare function seedHierarchy(scene: Scene, pid: string | null, direction: Direction): void;

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

@@ -0,0 +1,17 @@
+import type { Batch } from './arrange.ts';
+import type { Scene } from './scene.ts';
+import type { Axis, Item } from './types.ts';
+/**
+ * The guarded moves of one solve: a move that keeps an item in its frame and inside the pass's
+ * movement limit, the room an item has along one axis, and the pairwise pass that pushes
+ * overlapping items apart.
+ */
+export declare function createSeparation(scene: Scene, batch: Batch): {
+    constrainedMove: (p: Item, dx: number, dy: number) => void;
+    axisCapacity: (p: Item, axis: Axis, sign: number) => number;
+    separate: (rounds?: number) => void;
+    collisions: () => {
+        n: number;
+        a: number;
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { LayoutSettings } from '../../model/types.ts';
+import type { LayoutAlgorithm } from './types.ts';
+export declare const ALGORITHMS: LayoutAlgorithm[];
+export declare const defaults: LayoutSettings;
+/** Checked settings: defaults under `values`, old names mapped, numbers held to their ranges. */
+export declare function settings(values?: object): LayoutSettings;

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

@@ -0,0 +1,18 @@
+import type { LayoutIntent, Link, Settings, Topology } from './types.ts';
+/**
+ * The link structure of one solve: neighbours, feedback links, longest-path ranks and connected
+ * parts. Links stay as given; a feedback link is only left out of the ranks.
+ */
+export declare function topology<E extends Link>(items: Array<{
+    id: string;
+}>, edges: E[], intent?: LayoutIntent): Topology<E>;
+/** Hop counts between every pair of items that links join. */
+export declare function shortestPaths(t: Topology): Map<string, Map<string, number>>;
+export interface Forest {
+    roots: string[];
+    parent: Map<string, string>;
+    kids: Map<string, string[]>;
+    depth: Map<string, number>;
+}
+/** A breadth-first spanning forest: from the chosen root, then every source, then the rest. */
+export declare function forest(t: Topology, s: Settings): Forest;

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

@@ -0,0 +1,8 @@
+import type { Centres, Item, Link, Settings, Topology } from './types.ts';
+/** A span-based tree: each subtree gets its own width and parents sit over their children. */
+export declare function treeTarget(items: Item[], t: Topology, s: Settings): Centres;
+/** Rings round each root by depth. No solve reaches it: see `Settings`. */
+export declare function radialTarget(items: Item[], t: Topology, s: Settings): Centres;
+export declare function bilateralTarget(items: Item[], t: Topology, s: Settings): Centres | null;
+/** Which way a forward link should run: 1, -1 on the far side of a centred start, 0 across it. */
+export declare function forwardSign(t: Topology, e: Link): number;

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;