@draftably/editor 0.0.0-stage → 0.2.0

package/dist/types/src/model/graph.d.ts

@@ -0,0 +1,53 @@
+import type { Diagram, DiagramEdge, DiagramGroup, DiagramNode, Direction, Entity, NodeLayout, NodeStyle, Rect } from './types';
+export declare const findNode: (doc: Diagram, id: string | null | undefined) => DiagramNode | undefined;
+export declare const findGroup: (doc: Diagram, id: string | null | undefined) => DiagramGroup | undefined;
+export declare const findEdge: (doc: Diagram, id: string | null | undefined) => DiagramEdge | undefined;
+export declare const findObject: (doc: Diagram, id: string | null | undefined) => DiagramNode | DiagramGroup | undefined;
+export declare const findEntity: (doc: Diagram, id: string | null | undefined) => Entity | undefined;
+export declare const isNode: (doc: Diagram, id: string) => boolean;
+export declare const isGroup: (doc: Diagram, id: string) => boolean;
+export declare const isEdge: (doc: Diagram, id: string) => boolean;
+export declare const styleOf: (doc: Diagram, id: string) => NodeStyle;
+/** Direct children (shapes and containers) of a container, or of the diagram root. */
+/** The title band of a `cells` group; undefined for any other group. */
+export declare const cellsBandOf: (doc: Diagram, id: string | null | undefined) => number | undefined;
+/** Whether a cell is a field of variable length in a byte or bit layout. */
+export declare const isOpenCell: (doc: Diagram, id: string) => boolean;
+/** Whether a node is a cell of a `cells` group, which holds it in place edge to edge. */
+export declare const isCell: (doc: Diagram, id: string) => boolean;
+export declare function childrenOf(doc: Diagram, parentId: string | null | undefined): (DiagramNode | DiagramGroup)[];
+export declare function descendants(doc: Diagram, id: string): string[];
+/** Containers enclosing an object, nearest first. */
+export declare function ancestors(doc: Diagram, id: string): string[];
+export declare const isCollapsed: (doc: Diagram, id: string) => boolean;
+export declare const isHiddenByCollapse: (doc: Diagram, id: string) => boolean;
+/** The visible object that stands in for `id`: its outermost collapsed container, if any. */
+export declare function visibleProxy(doc: Diagram, id: string): string;
+export interface VisibleEdge extends DiagramEdge {
+    /** Visible source, which may be a collapsed container. */
+    a: string;
+    /** Visible target, which may be a collapsed container. */
+    b: string;
+}
+export interface VisibleGraph {
+    nodes: DiagramNode[];
+    groups: DiagramGroup[];
+    edges: VisibleEdge[];
+}
+/** Objects and connections that are not hidden inside a collapsed container. */
+export declare function visibleGraph(doc: Diagram): VisibleGraph;
+/** Selected shapes and containers whose own container is not also selected. */
+export declare function selectionRoots(doc: Diagram, selected: Iterable<string>): string[];
+/** Layout direction for the contents of an object's container. */
+export declare function inheritedDirection(doc: Diagram, id: string): Direction;
+export declare const COLLAPSED_HEIGHT = 58;
+export declare const CONTAINER_HEADER = 28;
+/** Read geometry for an object, preferring a temporary override (preview, animation, brush). */
+export type GeometryLookup = (id: string) => NodeLayout;
+export declare function makeGeometry(doc: Diagram, override?: Record<string, NodeLayout> | null): (id: string) => NodeLayout;
+/**
+ * Container frame as drawn: collapsed containers shrink to their title band plus a line for the
+ * shape count, so the title stays where it was in the open frame.
+ */
+export declare function frameRect(doc: Diagram, geometry: GeometryLookup, id: string): NodeLayout;
+export declare const objectRect: (doc: Diagram, geometry: GeometryLookup, id: string) => Rect;

package/dist/types/src/model/heading.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The title and subtitle drawn above an exported diagram, shared by `inspect --svg` and the
+ * editor's export, so a copied image still says what it shows.
+ */
+import type { Heading, ResolvedAppearance } from './appearance';
+/** Title type: the theme's title face, larger; subtitle type: its annotation face. */
+declare function types(look: ResolvedAppearance): {
+    title: import("./fonts").TypeProfile;
+    subtitle: import("./fonts").TypeProfile;
+};
+/**
+ * Width the subtitle wraps to over a drawing `room` wide: the drawing's width, held between 360px
+ * and about 70 characters, so a long subtitle wraps instead of widening the frame.
+ */
+export declare function subtitleMeasure(look: ResolvedAppearance, room: number): number;
+/** Size of the heading block, including the gap under it. Zero when there is nothing to draw. */
+export declare function headingSize(look: ResolvedAppearance, heading: Heading | undefined, wrap: number): {
+    w: number;
+    h: number;
+};
+/**
+ * Each line of the heading with its own type and box, top-left corner at (x, y). The title is one
+ * line; the subtitle wraps to `wrap` (`subtitleMeasure`).
+ */
+export declare function headingLines(look: ResolvedAppearance, heading: Heading | undefined, x: number, y: number, wrap: number): {
+    key: "title" | "subtitle";
+    text: string;
+    type: Type;
+    fill: string;
+    x: number;
+    y: number;
+}[];
+type Type = ReturnType<typeof types>['title'];
+/** SVG markup for the heading with its top-left corner at (x, y). */
+export declare function headingMarkup(look: ResolvedAppearance, heading: Heading | undefined, x: number, y: number, wrap: number): string;
+/** Title and subtitle type, for drawing and editing them in the viewer. */
+export declare const headingTypes: typeof types;
+export {};

package/dist/types/src/model/icons.d.ts

@@ -0,0 +1,2 @@
+/** SVG path data for interface and shape icons, drawn on a 24×24 grid. */
+export declare const ICONS: Record<string, string>;

package/dist/types/src/model/labels.d.ts

@@ -0,0 +1,88 @@
+import { type ResolvedAppearance } from './appearance';
+import { type TypeProfile } from './fonts';
+import type { Diagram, LabelMode, Rect, ShapeKind } from './types';
+/**
+ * Room for a shape's title. Every size, wrap and overflow decision goes through these functions,
+ * in the compiler, the canvas and the CLI alike.
+ */
+export interface TitleArea {
+    /** Line width available to the title. */
+    width: number;
+    /** Tallest text block that fits inside the shape at its current height. */
+    maxHeight: number;
+}
+export declare function titleArea(shape: ShapeKind, w: number, h: number, r: ResolvedAppearance, icon?: boolean): TitleArea;
+/** Height a shape needs for `lines` title lines; never less than `base`. */
+export declare function titleHeight(shape: ShapeKind, lines: number, base: number, r: ResolvedAppearance): number;
+/** A shape's title in balanced lines no wider than `width` (see `wrapLines`). */
+export declare const wrapTitle: (text: string, width: number, r: ResolvedAppearance) => string[];
+/**
+ * Line width for a diamond's title, `s` its side. A text block W wide and H tall fits inside a
+ * square diamond when W + H <= s, so this takes the widest measure whose wrapped lines still fit:
+ * the title reads in as few lines as the shape allows. Undefined when no measure fits.
+ */
+export declare function diamondMeasure(title: string, s: number, r: ResolvedAppearance): number | undefined;
+/** Most lines a group title wraps to; past that the frame widens instead. */
+export declare const GROUP_TITLE_LINES = 3;
+/** A group's header height when its title takes `lines` lines. */
+export declare const groupHeaderFor: (r: ResolvedAppearance, lines?: number) => number;
+/**
+ * A group title as drawn in a frame `w` wide: wrapped to at most `lines` lines (the compiler
+ * reserves that many), the last shortened with an ellipsis if the text runs on.
+ */
+export declare function groupTitleLines(title: string, w: number, r: ResolvedAppearance, lines?: number): string[];
+export interface NodeLabel {
+    /** Center of the label, relative to the shape's top-left corner. */
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    lines: string[];
+    mode: LabelMode;
+    lineHeight: number;
+    leader: boolean;
+}
+/** Where a shape's title is drawn, relative to the shape. */
+export declare function nodeLabel(doc: Diagram, id: string, title: string, r: Rect): NodeLabel;
+/** Bounds of a shape together with its label. */
+export declare function visualBounds(doc: Diagram, id: string, title: string, r: Rect): Rect;
+/** Text width a sequence message's label wraps to; the gap between participants follows it. */
+export declare const MESSAGE_WRAP = 168;
+/**
+ * The type a connection label is set in: the annotation type, or a step larger for a sequence
+ * message (`message`), whose label is the main thing to read.
+ */
+export declare const edgeLabelType: (r: ResolvedAppearance, message?: boolean) => TypeProfile;
+/**
+ * Text width a flow line's label wraps to: about 24 characters of the annotation type, so a short
+ * phrase stays on one line and a sentence stacks instead of widening its gap.
+ */
+export declare const LABEL_WRAP = 140;
+/**
+ * A connection label's lines: split at each `\n` and wrapped to `LABEL_WRAP`, or a sequence
+ * message's to `MESSAGE_WRAP`.
+ */
+export declare const edgeLabelLines: (label: string, r: ResolvedAppearance, message?: boolean) => string[];
+/**
+ * A self-message's loop: its run out to the right of the lifeline and its drop. Its label sits
+ * `label` past the loop, centred on the drop.
+ */
+export declare const SELF_LOOP: {
+    out: number;
+    down: number;
+    label: number;
+};
+/** Box for a connection label in the diagram's annotation type. */
+export declare function edgeLabelSize(label: string, r?: ResolvedAppearance, message?: boolean): {
+    w: number;
+    h: number;
+};
+/**
+ * What a self-message draws, measured from where its row meets the lifeline: how far right, how
+ * far above the row and how far below it.
+ */
+export declare function selfMessageInk(label: string | undefined, r: ResolvedAppearance): {
+    right: number;
+    above: number;
+    below: number;
+};

package/dist/types/src/model/legend.d.ts

@@ -0,0 +1,25 @@
+/** The color key drawn under an exported diagram, shared by `inspect --svg` and the editor's export. */
+import { type LegendEntry, type ResolvedAppearance } from './appearance';
+import { type StatusCount } from './status';
+/** The removed marker, a minus in a disc of radius `r`, centred at (x, y). */
+export declare const markerMarkup: (x: number, y: number, ink: string, canvas: string, r?: number) => string;
+/**
+ * Lay out the key: every `legend` entry, then every change mark used with its count, left to
+ * right, starting a new row only where the next entry would pass `max`. A short key is one row
+ * under the drawing. Zero size when there is nothing to show.
+ */
+export declare function legendSize(look: ResolvedAppearance, legend?: LegendEntry[], statuses?: StatusCount[], max?: number): {
+    w: number;
+    h: number;
+    row: number;
+    items: {
+        x: number;
+        y: number;
+        legend?: LegendEntry;
+        status?: StatusCount;
+        label: string;
+    }[];
+};
+export type LegendLayout = ReturnType<typeof legendSize>;
+/** SVG markup for the key laid out by `legendSize`, with its top-left corner at (x, y). */
+export declare function legendMarkup(look: ResolvedAppearance, key: LegendLayout, x: number, y: number): string;

package/dist/types/src/model/link.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Links on objects (`href=`): what a link points at, and where its mark sits on a shape.
+ *
+ * A link is kept as the author wrote it. A URL (`https://…`, `mailto:`) opens as written; a
+ * `.draft` opens in the viewer; anything else is a file path that opens in the editor. A file
+ * path may end in `:line` or `:line:col`, and a relative one starts at the link base: the git
+ * root of the diagram, unless the file sets `config link-base=`.
+ */
+import { type TypeProfile } from './fonts';
+export type LinkKind = 'url' | 'draft' | 'file';
+export interface LinkTarget {
+    kind: LinkKind;
+    /** The URL, or the file path without its line and column. */
+    path: string;
+    line?: number;
+    col?: number;
+}
+export declare function linkTarget(href: string): LinkTarget;
+/**
+ * A relative `href` against a URL `link-base` (`https://host/org/repo/blob/<sha>/`), as the URL
+ * it opens; null when the base is a folder or unset, or `href` is already a URL.
+ */
+export declare function baseUrl(href: string, base: string | undefined): string | null;
+/** Join and normalize forward-slash paths; an absolute `path` ignores `base`. */
+export declare function joinPath(base: string, path: string): string;
+/** The path from folder `from` to `to`, both absolute with forward slashes. */
+export declare function relativePath(from: string, to: string): string;
+/**
+ * A link as a static SVG carries it. A URL stays as written; a file or `.draft` becomes a path
+ * from the diagram's folder (a first guess at where the SVG is saved), without its line.
+ */
+export declare function staticHref(href: string, base: string, folder: string): string;
+/** Editors that open `<scheme>://file/<path>:<line>:<col>`. */
+export declare const EDITORS: readonly ["vscode", "vscode-insiders", "cursor", "windsurf", "zed"];
+export type Editor = (typeof EDITORS)[number];
+/** File settings from `config` statements. */
+export interface FileConfig {
+    /**
+     * Where relative links start: a folder relative to the diagram's (its git root when unset), or
+     * a URL that relative links are joined to.
+     */
+    linkBase?: string;
+    /** The editor file links open in; VS Code when unset. */
+    editor?: Editor;
+    /** Strike removed titles through in a diff; off when unset. */
+    strikeRemoved?: boolean;
+}
+export declare const editorUrl: (editor: Editor, file: string, line?: number, col?: number) => string;
+/** The link mark: a small arrow out of a shape's top-right corner, inside the shape when it can be. */
+export interface LinkMark {
+    x: number;
+    y: number;
+    size: number;
+    /** Inside the shape's fill (draw in its ink), or on the canvas beside it. */
+    inside: boolean;
+}
+export declare const LINK_MARK_SIZE = 10;
+/** `badge` is the width of a `count` badge on the corner, which the mark steps left of. */
+export declare function linkMark(shape: string, w: number, h: number, badge?: number): LinkMark;
+/** The mark next to a container's title. */
+export declare const groupLinkMark: (title: string, font: TypeProfile, band: number) => LinkMark;
+/** The arrow, in a 10×10 box. */
+export declare const LINK_MARK_PATH = "M2 8L8 2M3.5 2H8V6.5";

package/dist/types/src/model/markers.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The marks at a connection's ends, `head=` and `tail=` in a file. The canvas and the CLI draw
+ * them from these definitions, so both give the same geometry.
+ */
+import type { Point, Rect } from './types';
+/** What `head=` and `tail=` accept. A plain edge is `head=arrow tail=none`. */
+export declare const MARKERS: readonly ["arrow", "none", "triangle", "open-triangle", "diamond", "open-diamond", "circle", "cross"];
+export type EndMarker = (typeof MARKERS)[number];
+export interface MarkerShape {
+    w: number;
+    h: number;
+    /** Where the marker sits on its line, at the height of its middle. */
+    x: number;
+    d: string;
+    /** Solid marks take the line's ink. Open marks take the surface, which hides what is under. */
+    fill: 'ink' | 'surface' | 'none';
+    /** How far short of the end its line stops; the mark fills that gap, tip on the end. */
+    stop: number;
+}
+/** Each marker points along +x, in drawing units. `arrow` is the original open chevron. */
+export declare const MARKER_SHAPES: Record<Exclude<EndMarker, 'none'>, MarkerShape>;
+export declare const MARKER_STROKE = 1.5;
+/** The `<marker>` box for an end. A tail's mark turns to face away from the line. */
+export declare const markerBox: (kind: Exclude<EndMarker, "none">, tail: boolean) => {
+    markerWidth: number;
+    markerHeight: number;
+    refX: number;
+    refY: number;
+    orient: string;
+};
+/** The fill a marker takes on this line and surface. */
+export declare function markerFill(kind: Exclude<EndMarker, 'none'>, ink: string, surface: string): string;
+type Ends = {
+    directed?: boolean;
+    head?: EndMarker;
+    tail?: EndMarker;
+};
+/** An undirected edge has no marks, whatever else it holds. */
+export declare const headOf: (e: Ends) => EndMarker;
+export declare const tailOf: (e: Ends) => EndMarker;
+/** Whether an edge has anything beyond the plain arrow, which labels and lines ignore. */
+export declare const hasMarkers: (e: Ends) => boolean;
+/** A route with each end pulled back to its marker's stop, so no line runs through a mark. */
+export declare function stoppedPoints(points: Point[], e: Ends): Point[];
+/** The room an edge's marks take. A label keeps off them. */
+export declare function markerRects(points: Point[], e: Ends): Rect[];
+export {};

package/dist/types/src/model/note.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Notes: sentences on a diagram that never move its layout, from `note` statements. An anchored
+ * note (`near=`) is placed after layout in free space beside its object or sequence message; a
+ * note without one sits in the frame under the subtitle. The viewer, `inspect --svg` and the
+ * editor's exports all place and draw them from here.
+ */
+import { type ResolvedAppearance } from './appearance';
+import type { BoundedRoute } from './bounds';
+import { type Run } from './rich-text';
+import type { Diagram, Point, Rect } from './types';
+export declare const NOTE_SIDES: readonly ["below", "above", "left", "right"];
+export type NoteSide = (typeof NOTE_SIDES)[number];
+export interface Note {
+    text: string;
+    /** The node, group or sequence message the note sits beside; the frame when unset. */
+    near?: string;
+    /** Which side of `near`; `below` when unset, or `right` for a message. */
+    side?: NoteSide;
+    /** Wrap width; `NOTE_WIDTH` when unset. */
+    width?: number;
+}
+/**
+ * A note with its box and wrapped lines. `inFrame` notes sit under the subtitle; `overlaps` is set
+ * on an anchored note when no clear spot was found.
+ */
+export interface PlacedNote {
+    note: Note;
+    rect: Rect;
+    /** Wrapped lines, each as runs of plain text and links. */
+    lines: Run[][];
+    inFrame?: boolean;
+    overlaps?: boolean;
+}
+/** The side a note sits on: its `side`, or by default right of a message and below anything else. */
+export declare const noteSide: (doc: Diagram, note: Note) => NoteSide;
+/** Default wrap width, and the room between a note and its object. */
+export declare const NOTE_WIDTH = 280;
+/** Room between a note's panel and its text. */
+export declare const NOTE_PAD: {
+    x: number;
+    y: number;
+};
+/** The note's wrapped lines and box size, at 0,0. */
+export declare function noteBox(look: ResolvedAppearance, note: Note): PlacedNote;
+/**
+ * Spots in a sequence's side margins, by index in `notes`, for notes on the messages in `rows`.
+ * `left` and `right` are the margins' inner edges and `top` the highest a note goes. A note is
+ * level with its row, or pushed down clear of the note above it. The panel grows round these, so
+ * no note here can cover the drawing.
+ */
+export declare function marginNotes(look: ResolvedAppearance, notes: readonly Note[], rows: ReadonlyMap<string, number>, { left, right, top }: {
+    left: number;
+    right: number;
+    top: number;
+}): (Rect | null)[];
+/**
+ * Place every anchored note beside its object or message, clear of shapes, group borders, lines
+ * and earlier notes when a nearby spot allows it. Frame notes, and notes whose object is not drawn,
+ * come back `inFrame` at 0,0 for `diagramFrame` to place.
+ */
+export declare function placeNotes(doc: Diagram, look: ResolvedAppearance, rects: ReadonlyMap<string, Rect>, routes: readonly BoundedRoute[]): PlacedNote[];
+/**
+ * SVG markup for placed notes: a quiet panel with a bar on its left edge, then the text. Links
+ * are `<a>` elements with `href` as `write` gives it.
+ */
+export declare function noteMarkup(look: ResolvedAppearance, notes: readonly PlacedNote[], write?: (href: string) => string | null): string;
+/**
+ * Where a note dropped at `p` belongs: beside the closest object or (in a sequence) message, on
+ * the side of it `p` is on. Inside several objects the smallest wins, so a note dropped on a
+ * shape in a group goes to the shape. Undefined when nothing is within reach.
+ */
+export declare function noteAnchor(p: Point, rects: ReadonlyMap<string, Rect>, messages?: readonly BoundedRoute[]): {
+    near: string;
+    side: NoteSide;
+} | undefined;

package/dist/types/src/model/panels.d.ts

@@ -0,0 +1,11 @@
+import type { Diagram } from './types';
+export type PanelSide = 'before' | 'after';
+/**
+ * The merged document with each change as it was: old labels, shapes, counts, rows and phase
+ * bands. Every object stays in its place and every line stays in.
+ */
+export declare function oldDoc(doc: Diagram): Diagram;
+/** Panels repeat the drawing and put its notes in the frame, so a sequence drops its margins. */
+export declare function withoutMargins(doc: Diagram): Diagram;
+/** The document as it was (`before`: no added objects, old values) or is (`after`: no removed). */
+export declare function panelDoc(doc: Diagram, side: PanelSide): Diagram;

package/dist/types/src/model/rich-text.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Prose with links, for notes and footnotes: `[#1997](https://github.com/org/repo/pull/1997)`
+ * draws `#1997` as a link. Lines wrap exactly as the plain words would, so a link never moves
+ * anything; each line comes back as runs with their offsets, for SVG `<a>` and click targets.
+ */
+import { type TypeProfile } from './fonts';
+export interface Run {
+    text: string;
+    href?: string;
+    /** Offset from the line's start, and width. */
+    x: number;
+    w: number;
+}
+/** The text as drawn, with every link written as its label. */
+export declare const plainText: (text: string) => string;
+/** Every link's target, in order. */
+export declare const textLinks: (text: string) => string[];
+/** The text's lines at `width`, each as runs of plain text and links. */
+export declare function richLines(text: string, width: number, type: TypeProfile): Run[][];
+/**
+ * One line's content inside its `<text>`: plain runs as text, links as an underlined `<tspan>` in
+ * `link`, wrapped in `<a>` with `href` as `write` gives it.
+ */
+export declare function runsMarkup(runs: Run[], link: string, write: (href: string) => string | null): string;

package/dist/types/src/model/routes.d.ts

@@ -0,0 +1,170 @@
+import { type PriorRoute, type Route, type RoutingResult } from '../engines/routing-engine.js';
+import { type ResolvedAppearance } from './appearance';
+import { type VisibleGraph } from './graph';
+import type { Diagram, EdgeLayout, Point, Rect, ShapeKind, Side } from './types';
+export declare const SIDE_VECTORS: Record<Side, Point>;
+/** Where a connection meets a shape's outline on the given side. */
+export declare function portPoint(shape: ShapeKind, r: Rect, side: Side, offset?: number): Point;
+/** Side of `r` facing `p`. */
+export declare function sideToward(r: Rect, p: Point): Side;
+export interface EdgeLabelBox extends Point {
+    w: number;
+    h: number;
+    score?: number;
+}
+/** Lines and borders a label may sit on only when nothing better is free. */
+export interface LabelAvoid {
+    /** Other edges' routes. Routes that leave from this edge's first point share its trunk. */
+    routes?: Point[][];
+    /** Thin strips along group borders. */
+    borders?: Rect[];
+    /** The marks at line ends. A spot that hides one costs as much as a line through the text. */
+    marks?: Rect[];
+    /** The open group that holds both ends. A spot not inside it costs a little less than a line. */
+    home?: Rect;
+}
+/** One edge label for `placeEdgeLabels`: its text, its route, and what it should keep clear of. */
+export interface LabelJob {
+    label: string;
+    points: Point[];
+    avoid?: LabelAvoid;
+    /** The user's nudge, added to the chosen spot. */
+    dx?: number;
+    dy?: number;
+}
+/**
+ * Place every edge label at once, after all routes exist. Each label takes a spot on its own
+ * route that covers no shape, group title or other label, and crosses as few other lines as it
+ * can; a label closer to another than its own height costs as much as a line beside it. Labels
+ * with a clean spot go first, then one repair sweep moves each label to its best spot given all
+ * the others. Only a label with every spot near its route blocked moves away from it, and then as
+ * little as possible.
+ */
+export declare function placeEdgeLabels(jobs: LabelJob[], obstacles: Rect[], look?: ResolvedAppearance, fixed?: Rect[]): EdgeLabelBox[];
+/**
+ * Choose a label spot on the edge's own route, clear of the labels already placed: see
+ * `placeEdgeLabels`.
+ */
+export declare function placeEdgeLabel(label: string, points: Point[], obstacles: Rect[], existing?: Rect[], look?: ResolvedAppearance, avoid?: LabelAvoid): EdgeLabelBox;
+export interface DrawnRoute extends Route {
+    label: EdgeLabelBox | null;
+    path: string;
+    /**
+     * Short pieces of the line where it crosses another line or a group's frame: the only places a
+     * canvas-colored halo is drawn under it, so the crossing reads as a clean break. Empty when the
+     * line crosses nothing.
+     */
+    halo: string;
+    /**
+     * For a line to or from a cell with no side on its group's outline: the stretch from the outline
+     * across other cells to that cell's edge. It is drawn over the cells, with a dot at the edge.
+     */
+    cross?: [Point, Point];
+}
+export interface SceneRoutes {
+    routes: DrawnRoute[];
+    result: RoutingResult;
+}
+/**
+ * An edge's routing settings, with its lane turned into bends and sides: out of the source to
+ * the lane, along it, and into the target. A lane with `leave` or `enter` turns at that coordinate beside
+ * the source or target, to meet it side on. A lane that no longer lies between the two ends (a
+ * node was dragged across it) is ignored, as is any lane on an edge with its own bends.
+ */
+export declare function laneBends(cfg: EdgeLayout, a: Rect, b: Rect): EdgeLayout;
+export declare function routeInput(doc: Diagram, vg: VisibleGraph, all: Map<string, Rect>): {
+    nodes: ({
+        shape: ShapeKind;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        id: string;
+        title: string;
+        was?: string;
+        wasShape?: ShapeKind;
+        wasCount?: number | string;
+        href?: string;
+        count?: number | string;
+        span?: number | "var";
+        parentId?: string;
+        image?: string;
+        lifeline?: number;
+    } | {
+        parentId?: string | undefined;
+        frame?: boolean | undefined;
+        shape: ShapeKind;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        id: string;
+        title: string;
+    })[];
+    groups: {
+        titleHeight?: number | undefined;
+        collapsed: boolean;
+        titleWidth: number;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        id: string;
+        title: string;
+        was?: string;
+        href?: string;
+        parentId?: string;
+        frame?: "soft" | "none";
+        titleLines?: number;
+        hull?: Rect[];
+    }[];
+    edges: {
+        from: string;
+        to: string;
+        cfg: EdgeLayout;
+        a: string;
+        b: string;
+        id: string;
+        label: string;
+        was?: string;
+        directed: boolean;
+        head?: import("./markers").EndMarker;
+        tail?: import("./markers").EndMarker;
+        emphasis: boolean;
+        dashed: boolean;
+        status?: import("./status.js").Status;
+        spot?: import("./status.js").Spot;
+    }[];
+};
+/**
+ * A labelled route with no run the label clears slides one bend along, so one run holds the label
+ * away from the bend; a label on the corner reads as part of neither run. `w` and `h` are the
+ * label's box. The bend moves the least that gives a run the label plus `LABEL_RUN` at each end,
+ * or as close to that as the route allows while the label still clears both ends. The move stands
+ * only when the route stays out of every box, crosses no more lines and runs beside no more.
+ */
+export declare function roomForLabel(points: Point[], w: number, h: number, boxes: Rect[], others: Point[][]): Point[];
+/** Add label positions and SVG paths to raw routes. */
+export declare function drawRoutes(doc: Diagram, vg: VisibleGraph, rects: Map<string, Rect>, result: RoutingResult): DrawnRoute[];
+/** Width of the halo under a connection, in drawing units. */
+export declare const HALO_WIDTH = 8;
+/** How far a halo piece runs each way from a crossing, along the line. */
+export declare const HALO_REACH = 7;
+/**
+ * The lines, by index, that another line's halo would cut at a mark. A halo there leaves half a
+ * mark, or on a short line almost nothing, so these lines stay whole.
+ */
+export declare function wholeLines(lines: {
+    points: Point[];
+    marks: Rect[];
+}[]): Set<number>;
+/** The pieces of `points` around each place it crosses `others` or a frame's border, as a path. */
+export declare function haloPath(points: Point[], others: Point[][], frames: Rect[]): string;
+/** Full routes already computed for this drawing, or null. */
+export declare function knownRoutes(doc: Diagram, vg: VisibleGraph, rects: Map<string, Rect>): RoutingResult | null;
+/** Record full routes computed elsewhere (the engine worker) for this drawing. */
+export declare function rememberRoutes(doc: Diagram, vg: VisibleGraph, rects: Map<string, Rect>, result: RoutingResult): void;
+export declare function computeRoutes(doc: Diagram, vg: VisibleGraph, rects: Map<string, Rect>, options?: {
+    previous?: PriorRoute[];
+    quick?: boolean;
+}): SceneRoutes;

package/dist/types/src/model/samples.d.ts

@@ -0,0 +1,11 @@
+import type { Diagram } from './types';
+export interface SampleInfo {
+    id: string;
+    title: string;
+    icon: string;
+}
+/** Examples in menu order. Each id names a file in `src/samples/`. */
+export declare const SAMPLES: SampleInfo[];
+export declare const DEFAULT_SAMPLE = "automatic-ports";
+/** A fresh copy of an example, with its own document id. */
+export declare function loadSample(id: string): Diagram;

package/dist/types/src/model/stack.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A node with `count` stands for many things: two offset outlines behind it read as a stack, and
+ * a badge on its corner says how many. Shared by the canvas and the SVG output.
+ */
+/** Offsets of the outlines behind the node, back to front. */
+export declare const STACK_OFFSETS: number[];
+/** The badge's text: `×42`, `×1.2k` for large counts, or `×N` for a symbol. */
+export declare function countText(count: number | string): string;