@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.1

package/dist/components/types/uhd-viewer/src/cad/model.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 3D view model (PB-775): what to load and where, derived from UHD alone.
+ *
+ * - Placements come from `assemble` (mechanical links with frames).
+ * - Each placement's body is the module's GLB artifact for that body.
+ * - Each interface reports how it is bound, per direction:
+ *     feature    D1  named sub-shape in the body artifact (+ signature)
+ *     artifact   D2  its own artifact file
+ *     procedural D3  derived from its parameters at its frame
+ *   plus whether it is logical, unmapped, or resolved through its children.
+ */
+import type { ArtifactDef, GeometryFrame, GeometryRef, InterfaceDef, ModuleDef } from "@deltarobotics/uhd";
+import { type Assembly, type GeometryBindingIssue, type GeometryManifest, type Mat4 } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+/** Artifact URL for a definition's (relative) file path: supplied by the viewer's source. */
+import type { ArtifactResolver } from "../api";
+export type { ArtifactResolver };
+export type Direction = "feature" | "artifact" | "procedural";
+export declare const DIRECTIONS: {
+    id: Direction;
+    label: string;
+    hint: string;
+    icon: string;
+}[];
+export interface CadBody {
+    key: string;
+    path: string[];
+    def: ModuleDef;
+    /** GLB to load, if the module has one for this body. */
+    glb?: ArtifactDef;
+    /** The body artifact id feature refs point at (STEP or vendor source). */
+    bodyArtifact?: string;
+    matrix: Mat4;
+    via?: string;
+    /** Placed by a hint, not by a link. */
+    hint?: string;
+    /**
+     * Nothing places it: it is drawn beside the others in a row, laid out
+     * once its model is loaded (PB-1040), and the view says it is unplaced.
+     */
+    row?: boolean;
+}
+export type BindingStatus = "bound" | "stale" | "missing" | "unchecked" | "none";
+export interface InterfaceRow {
+    iface: InterfaceDef;
+    frame?: GeometryFrame;
+    /** Geometry comes from these interfaces (itself, or its children). */
+    sources: string[];
+    refs: {
+        interfaceId: string;
+        ref: GeometryRef;
+    }[];
+    logical: boolean;
+    /** No frame and no refs, on itself or any child. */
+    unmapped: boolean;
+    /** Per-direction resolution. */
+    byDirection: Record<Direction, {
+        interfaceId: string;
+        ref: GeometryRef;
+        status: BindingStatus;
+        note?: string;
+    }[]>;
+    issues: GeometryBindingIssue[];
+}
+export interface CadModel {
+    assembly: Assembly;
+    bodies: CadBody[];
+    /** module path key -> def, for every leaf instance */
+    defs: Map<string, ModuleDef>;
+    manifests: Map<string, GeometryManifest>;
+    /**
+     * Instances drawn inside another module's body rather than placed: the
+     * components of a board whose body (board.glb) shows them (PB-823). Path
+     * key → the body key that holds them.
+     */
+    within: Map<string, string>;
+    /**
+     * Where the placements come from when not from the module's own assembly
+     * (PB-1040): an ancestor's assembly cut down to the module (`from` is the
+     * ancestor's path from the root, `""` the root), or nothing at all, the
+     * models side by side (`row`).
+     */
+    placedBy?: {
+        kind: "ancestor";
+        from: string;
+    } | {
+        kind: "row";
+    };
+}
+/** The definition at an instance path below `system` ([] is the system itself). */
+export declare function defAt(system: ModuleDef, lookup: ModuleLookup, path: string[]): ModuleDef | undefined;
+/** Artifact id of the GLB for a body: the one generated from `bodyArtifact`, or the module's first body GLB. */
+export declare function glbFor(def: ModuleDef, bodyArtifact?: string): ArtifactDef | undefined;
+/** Fetch every manifest JSON the modules declare (artifacts with format json generated from a body). */
+export declare function loadManifests(defs: ModuleDef[], resolve: ArtifactResolver): Promise<Map<string, GeometryManifest>>;
+export declare function buildCadModel(system: ModuleDef, lookup: ModuleLookup, manifests: Map<string, GeometryManifest>, hints?: {
+    path: string[];
+    matrix: Mat4;
+    note: string;
+}[], rootPath?: string[]): CadModel;
+/**
+ * The model with every part that nothing places, but that has a model of
+ * its own, added as a body in a row beside the rest (PB-1040): a module's
+ * 3D view never leaves out a part that has a model. The row is laid out by
+ * the view once the models are loaded (their sizes are known then). Undefined
+ * when there is no such part.
+ */
+export declare function withUnplacedInRow(model: CadModel, shown: ModuleDef, lookup: ModuleLookup): CadModel | undefined;
+/**
+ * The named bodies a GLB comes apart into when exploded (D17): the largest
+ * stays, the rest move away from it. Only a cad standard output does this:
+ * `body.glb` with a `body.manifest.json` whose `bodies` lists two or more (an
+ * enclosure's back and lid), when the manifest was generated from the GLB, or
+ * when the module's print or cut exports make those bodies as separate pieces
+ * (`lid.stl` beside `base.stl`: both came from the same export). A vendor or
+ * library part's GLB stays rigid even when its manifest names several bodies
+ * (a motor's bell and stator, a prop's hub and blades).
+ */
+export declare function explodeParts(def: ModuleDef, glb: ArtifactDef | undefined, manifest: GeometryManifest | undefined): {
+    fixed: string;
+    moving: string[];
+} | undefined;
+export declare function interfaceRows(def: ModuleDef, manifests: Map<string, GeometryManifest>): InterfaceRow[];
+/** Bolt-pattern / shaft parameters for procedural geometry (D3). */
+export declare function param(iface: InterfaceDef, id: string): number | undefined;
+export declare function traitParam<T>(iface: InterfaceDef, type: string, key: string): T | undefined;
+/**
+ * The instance the assembly is placed from when the display hints don't say:
+ * the system itself when it has a body of its own, else the top-level module
+ * with the most interface frames (the structure the others mount to).
+ */
+export declare function defaultRoot(system: ModuleDef, lookup: (id: string) => ModuleDef | undefined): string[];

package/dist/components/types/uhd-viewer/src/cad/row.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+/**
+ * Bodies that nothing places (PB-1040) in a row beside what is placed, once
+ * their models are loaded and their sizes known: along x, after the placed
+ * bodies, centred on them across and resting on their lowest point; from the
+ * origin when nothing is placed. Each one's `base` is where it now sits.
+ */
+export declare function layOutRow(recs: {
+    body: {
+        row?: boolean;
+    };
+    base: THREE.Matrix4;
+    obj: THREE.Object3D;
+    box: THREE.Box3;
+}[]): void;

package/dist/components/types/uhd-viewer/src/cad/scene.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Imperative three.js scene for the 3D view (PB-775). Units: mm, Z up.
+ *
+ * GLB artifacts are glTF (metres, Y up); each is wrapped in a group that
+ * rotates +90° about X and scales ×1000, which returns it to the module's
+ * own CAD coordinates — the coordinates UHD frames are written in.
+ */
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
+import { type GLTF } from "three/examples/jsm/loaders/GLTFLoader.js";
+import type { GeometryFrame, InterfaceDef, ModuleDef } from "@deltarobotics/uhd";
+import type { Mat4 } from "@deltarobotics/uhd";
+import type { Appearance } from "../source/source";
+/** The theme's colours for the scene, as `#rrggbb` (ThemeProvider's tokenColor). */
+export interface SceneTheme {
+    background: string;
+    grid: string;
+    gridMinor: string;
+    accent: string;
+    highlight: string;
+}
+/**
+ * Highlight colours of one scene. The focus colours follow the theme's accent
+ * and highlight tokens; the rest are data colours. Each scene owns its set, so
+ * two viewers with different themes never share focus colours.
+ */
+export interface SceneColors {
+    focus: number;
+    counterpart: number;
+    normal: number;
+    xAxis: number;
+    phase: number[];
+    hint: number;
+    /** The selected body's emissive glow, and a stronger one for a picked interface's body. */
+    glow: number;
+    glowStrong: number;
+}
+/** The neutral default theme's accent and highlight (the stylesheet defaults), used until a theme is read. */
+export declare const DEFAULT_SCENE_ACCENT = "#339fee";
+export declare const DEFAULT_SCENE_HIGHLIGHT = "#22d3ee";
+/** Fresh scene colours for a theme's accent and highlight (the selected body glows a dim accent). */
+export declare function sceneColors(theme?: Pick<SceneTheme, "accent" | "highlight">): SceneColors;
+/** WCAG relative luminance of a colour (0 black … 1 white). */
+export declare function relativeLuminance(c: THREE.Color): number;
+/** Load a GLB by URL (artifact URLs come from the viewer source's resolver). */
+export declare function loadGlb(url: string): Promise<GLTF | null>;
+/** glTF (m, Y-up) back to CAD coordinates (mm, Z-up). */
+export declare function cadWrapper(obj: THREE.Object3D): THREE.Group;
+export declare function toMatrix4(m: Mat4): THREE.Matrix4;
+/**
+ * Surface for a module's body (or one named sub-body of its CAD), from, in
+ * order: display hints for the definition (and part), the part's declared
+ * material (UHD MaterialSpec), then neutral defaults by kind. Nothing here
+ * knows a particular project.
+ */
+export declare function materialFor(def: ModuleDef, bodyPart: string, appearance?: Appearance): THREE.MeshStandardMaterial;
+export declare const focusMaterial: (color: number) => THREE.MeshStandardMaterial;
+/** Group whose local X/Y/Z are the frame's xAxis / (normal × xAxis) / normal, origin at the frame origin. */
+export declare function frameGroup(frame: GeometryFrame): THREE.Group;
+export declare function frameGizmo(frame: GeometryFrame, colors: SceneColors, size?: number): THREE.Group;
+/**
+ * D3: geometry derived from the interface's own parameters, placed at its
+ * frame. Returns null when the generator has nothing to work with. `notes`
+ * collects what the parameters could not say (e.g. pattern phase).
+ */
+export declare function proceduralGeometry(iface: InterfaceDef, generator: string, frame: GeometryFrame, color: number, notes: string[]): THREE.Object3D | null;
+export interface SceneHandle {
+    scene: THREE.Scene;
+    camera: THREE.PerspectiveCamera;
+    controls: OrbitControls;
+    renderer: THREE.WebGLRenderer;
+    root: THREE.Group;
+    overlay: THREE.Group;
+    dispose: () => void;
+    frameAll: (box?: THREE.Box3) => void;
+    /**
+     * The model direction drawn up (default +z): the camera's up, the orbit
+     * axis, the ground grid and the lights follow it (a display hint, PB-873).
+     */
+    setUp: (up: THREE.Vector3) => void;
+    /** Put the ground grid under a box (the assembled model), across the up direction. */
+    setGround: (box: THREE.Box3) => void;
+    /** This scene's highlight colours (follow `setTheme`). */
+    colors: SceneColors;
+    /** The theme's background, grid and focus colours. */
+    setTheme: (theme: SceneTheme) => void;
+    /** Called every frame before rendering, with the frame time in seconds. */
+    onFrame: Set<(dt: number) => void>;
+    /** When set, the render loop is driven externally (video capture). */
+    manual: {
+        on: boolean;
+    };
+    renderOnce: () => void;
+}
+export declare function createScene(container: HTMLElement): SceneHandle;

package/dist/components/types/uhd-viewer/src/cad/scope.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The 3D view of one module (PB-897): a system's view shows the whole
+ * assembly, a module's shows that module alone, in its own coordinates. The
+ * model is then built from the module's definition, so every path in it is
+ * relative to the module; a host's paths, the display hints and the findings
+ * are all written from the root. These functions translate between the two,
+ * and say what a view shows and what it leaves out.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+import type { GeometryManifest, Mat4 } from "@deltarobotics/uhd";
+import { type CadModel } from "./model";
+/** A path from the root as a path inside `scope` ("" is the scope's own module); undefined when it is outside. */
+export declare function intoScope(path: string, scope: string): string | undefined;
+/** A path inside `scope` as a path from the root. */
+export declare function outOfScope(path: string, scope: string): string;
+/**
+ * A finding's reference from the root (`board/u2:pin_14`, `board:sda`,
+ * `link:board/<id>`) as one inside `scope`; undefined when it names
+ * something outside.
+ */
+export declare function scopeRef(ref: string, scope: string): string | undefined;
+/** The display hints' placements (keyed by path from the root, `#body` kept) that lie inside `scope`, re-keyed to it. */
+export declare function scopedPlacements<T extends {
+    matrix: Mat4;
+    note?: string;
+}>(placements: Record<string, T> | undefined, scope: string): {
+    path: string[];
+    matrix: Mat4;
+    note: string;
+}[];
+/** The display hints' assembly root (a path from the root) inside `scope`; undefined when it is not, or none is given. */
+export declare function scopedRoot(root: string | undefined, scope: string): string[] | undefined;
+/** The modules above `scope`, nearest first, as paths from the root (`""` is the root). */
+export declare function ancestorsOf(scope: string): string[];
+/**
+ * A model of an ancestor cut down to the module at `rel` (its path inside
+ * the ancestor) and re-keyed to it (PB-1040): what a module with no assembly
+ * of its own shows, its parts where the ancestor's assembly puts them. The
+ * matrices stay in the ancestor's coordinates (the view fits what is drawn);
+ * mates, routes and hardware are kept only when both of their ends lie in
+ * the module, and harnesses when they are in it.
+ */
+export declare function borrowModel(model: CadModel, rel: string[], from: string): CadModel;
+export interface Unplaced {
+    /** Child id in the shown module. */
+    id: string;
+    name: string;
+}
+/** What a 3D view shows of a module, and what it does not. */
+export interface ShownSummary {
+    /** The module has a body of its own (a board's `board.glb`): it is drawn as that body, its children in it. */
+    ownBody: boolean;
+    /** The module's direct children that are parts (harnesses are drawn as cables and hardware, not counted). */
+    parts: number;
+    /** Those of them that are drawn: placed, or inside the module's own body. */
+    placed: Unplaced[];
+    /** Those that are not: nothing says where they sit. */
+    unplaced: Unplaced[];
+    /** Those of `placed` that nothing places either, drawn beside the others (PB-1040). */
+    inRow: Unplaced[];
+    /**
+     * Nothing joins the module's parts: it has no body of its own, more than
+     * one part, and no mate or hint places a second one. What would be drawn
+     * is one part on its own, which is not a picture of the module.
+     */
+    loose: boolean;
+}
+export declare function shownSummary(model: CadModel, shown: ModuleDef, lookup: ModuleLookup): ShownSummary;
+/**
+ * The model a 3D view draws of the module at `at` (a path from the root;
+ * `""` is the root), PB-897 and PB-1040:
+ *
+ * 1. the module's own assembly: its mates and the display hints inside it;
+ * 2. when that leaves parts unplaced and the module has no body of its own,
+ *    the nearest ancestor whose assembly places more of them: its assembly,
+ *    cut down to the module (`borrowModel`);
+ * 3. what nothing places but has a model is drawn beside the rest, in a row
+ *    (`withUnplacedInRow`), and the view says so.
+ *
+ * The root's view is its own assembly, as before.
+ */
+export declare function scopedModel(system: ModuleDef, lookup: ModuleLookup, manifests: Map<string, GeometryManifest>, display: {
+    placements?: Record<string, {
+        matrix: Mat4;
+        note?: string;
+    }>;
+    root?: string;
+}, at: string): CadModel;

package/dist/components/types/uhd-viewer/src/canvas/Canvas.d.ts

@@ -0,0 +1,90 @@
+import type { ViewModel } from "../model/types";
+import type { NodeMark } from "../api";
+import { type Classification } from "../model/classification";
+import type { ComputedLayout } from "../layout/layout";
+import type { LevelLayout, LinkLayout } from "../layout/layout";
+import { type Detail } from "./LinkEdge";
+import type { Pt } from "./routing";
+import type { Isolation } from "../model/isolate";
+import type { Live } from "../viewer/controller";
+import { type InteractionAction, type InteractionState, type Viewport } from "./interaction";
+/** A view command from outside the canvas (a toolbar, a menu): fit, or a zoom step; `seq` tells repeats apart. */
+export interface ViewCommand {
+    type: "fit" | "in" | "out" | "reset";
+    seq: number;
+}
+export type Selection = {
+    kind: "node" | "link";
+    id: string;
+} | null;
+/** Fit padding that keeps the diagram clear of the floating chrome: the header, the toolbar and, when open, the inspector. */
+export declare const fitPadding: (inspector: boolean) => {
+    readonly top: "56px";
+    readonly bottom: "72px";
+    readonly left: "64px";
+    readonly right: "376px" | "64px";
+};
+export interface CanvasProps {
+    vm: ViewModel;
+    /** The inspector is open over the right of the canvas (fitting leaves room for it). */
+    inspector?: boolean;
+    layout: ComputedLayout;
+    hand?: LevelLayout;
+    mode: Classification;
+    detail: Detail;
+    showGrounds: boolean;
+    openLinks: Set<string>;
+    selection: Selection;
+    onSelect: (s: Selection) => void;
+    onToggleLink: (id: string) => void;
+    onLayout: (linkId: string, patch: LinkLayout) => void;
+    onPins: (linkId: string, pins: Pt[]) => void;
+    onToggleExpand: (id: string) => void;
+    /** Double-click on a node (default: expand it in place). */
+    onOpenNode?: (id: string) => void;
+    onMove: (id: string, x: number, y: number) => void;
+    /** A drag starts (what moves) or ends (null): the layout reroutes only what moves meanwhile. */
+    onLive: (live: Live | null) => void;
+    /**
+     * A node to bring into view (a host's focus, a row of the hierarchy), once it is drawn; `seq` tells repeats
+     * apart. With `lines`, a harness drawn along lines (no card of its own): those lines are framed.
+     */
+    centre?: {
+        id: string;
+        seq: number;
+        lines?: readonly string[];
+    };
+    /** A selection to bring into view if it is not (a host's select): panned to, zoomed out only if it must; `seq` tells repeats apart. */
+    reveal?: {
+        selection: NonNullable<Selection>;
+        seq: number;
+    };
+    /** Right-click on a node: its context menu at the pointer (the browser's own when not given). */
+    onNodeContext?: (id: string, x: number, y: number) => void;
+    /** The host's marks by definition id (`ViewerOptions.nodeMarks`). */
+    marks?: Record<string, NodeMark>;
+    /** Legend entries are isolated: what stays at full strength (the rest fades). */
+    isolation?: Isolation | null;
+    /** Modules selected together (a selection box, clicks with Shift, Ctrl or Cmd, select all): two or more, else empty. */
+    group?: readonly string[];
+    /** React Flow selected or unselected modules (a box, a click with a key held, a press on a module): the changes, a rail's taps named as the rail. */
+    onSelectChanges?: (changes: {
+        id: string;
+        selected: boolean;
+    }[]) => void;
+    /** The tool chosen and whether Space is held (default: select). */
+    interaction?: InteractionState;
+    onInteraction?: (action: InteractionAction) => void;
+    /** Ctrl/Cmd+A, and Escape. */
+    onSelectAll?: () => void;
+    onEscape?: () => void;
+    /** Fit or zoom, asked for by a toolbar or a menu. */
+    command?: ViewCommand;
+    /** The viewport saved for this level: put back when the canvas opens (none: the diagram is fitted). */
+    viewport?: Viewport;
+    /** The user moved the view (its viewport), or asked for a fit (null: nothing is kept, the next opening fits). */
+    onViewport?: (viewport: Viewport | null) => void;
+    /** Right-click on the empty canvas: its menu at the pointer (the browser's own when not given). */
+    onPaneContext?: (x: number, y: number) => void;
+}
+export declare function Canvas(props: CanvasProps): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/canvas/Icon.d.ts

@@ -0,0 +1,5 @@
+import { type LucideProps } from "lucide-react";
+/** Lucide icon by kebab-case name (UHD display hints use Lucide names). */
+export declare function Icon({ name, ...props }: {
+    name: string;
+} & LucideProps): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/canvas/LinkEdge.d.ts

@@ -0,0 +1,40 @@
+import { type Edge, type EdgeProps } from "@xyflow/react";
+import type { ViewLink } from "../model/types";
+import { type Classification } from "../model/classification";
+import { type Pt } from "./routing";
+import type { LinkLayout } from "../layout/layout";
+import type { Live } from "../viewer/controller";
+export type Detail = "basic" | "ribbon";
+export interface LinkData extends Record<string, unknown> {
+    link: ViewLink;
+    points: Pt[];
+    color: string;
+    faded: boolean;
+    mode: Classification;
+    detail: Detail;
+    /** Expanded (lanes shown). */
+    open: boolean;
+    openLanes: Set<string>;
+    /** Harness span along the route (arc lengths). */
+    run?: [number, number];
+    /** Label + toggle position (arc length); absent: no label. */
+    labelAt?: number;
+    /** The label was placed by the user (or the display file): honour it even on a short stretch. */
+    labelFixed?: boolean;
+    pins: Pt[];
+    bends: Pt[];
+    onToggle: (id: string) => void;
+    onToggleLane: (id: string) => void;
+    /** Select the link (a click on its label: the label stops the edge's own click). */
+    onSelect?: (linkId: string) => void;
+    /** Where the user put the label and harness tab (and which side of the line). */
+    edit?: LinkLayout;
+    onLayout: (linkId: string, patch: LinkLayout) => void;
+    onPins: (linkId: string, pins: Pt[]) => void;
+    onLive: (live: Live | null) => void;
+}
+export type LinkEdgeType = Edge<LinkData, "link">;
+export declare function LinkEdge({ id, data, selected }: EdgeProps<LinkEdgeType>): import("react").JSX.Element | null;
+export declare const edgeTypes: {
+    link: typeof LinkEdge;
+};

package/dist/components/types/uhd-viewer/src/canvas/Port.d.ts

@@ -0,0 +1,18 @@
+import type { PlacedPort } from "../layout/layout";
+export interface PortProps {
+    placed: PlacedPort;
+    /** Position relative to the node's top-left corner. */
+    x: number;
+    y: number;
+    color: string;
+    faded: boolean;
+    exported?: boolean;
+    label?: boolean;
+    ground?: boolean;
+    selected?: boolean;
+    /** Draw the dot (off where a ribbon's pin handle already marks the port). */
+    dot?: boolean;
+    /** Max label width in px (from port spacing and card size). */
+    labelWidth?: number;
+}
+export declare function Port({ placed, x, y, color, faded, exported, label, ground, selected, dot, labelWidth }: PortProps): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/canvas/actions.d.ts

@@ -0,0 +1,5 @@
+export interface CanvasActions {
+    onToggleExpand?: (id: string) => void;
+}
+export declare const CanvasActionsContext: import("react").Context<CanvasActions>;
+export declare const useCanvasActions: () => CanvasActions;

package/dist/components/types/uhd-viewer/src/canvas/geometry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Geometry along a routed link (PB-803): positions by arc length, sub-paths,
+ * lanes that fan out of the centre line, and harness regions traced around
+ * whatever runs through them. Pure functions, no React.
+ */
+import { type Pt } from "./routing";
+export declare const RUN = 24;
+export declare const LANE_PITCH = 16;
+export declare const RIBBON_PITCH = 6;
+export declare function lengths(points: Pt[]): number[];
+export declare const totalLength: (points: Pt[]) => number;
+/** Point and unit direction at arc length `s`. */
+export declare function at(points: Pt[], s: number): {
+    p: Pt;
+    d: Pt;
+};
+/** The polyline between arc lengths s0 and s1. */
+export declare function subpath(points: Pt[], s0: number, s1: number): Pt[];
+/** Arc length of the point on the polyline nearest to `q`. */
+export declare function project(points: Pt[], q: Pt): number;
+export declare function densify(points: Pt[], step?: number): Pt[];
+/** Offsets for n lanes centred on the line. */
+export declare const offsets: (n: number, pitch: number) => number[];
+/** Fillet radius for the centre line of a ribbon `width` wide, so its inner conductor still turns round. */
+export declare const ribbonRadius: (width: number) => number;
+/** Stroke points of a ribbon (parallel conductors at a fixed pitch) along the whole route. */
+export declare function ribbon(points: Pt[], n: number, radius?: number): {
+    d: string;
+    samples: Pt[];
+}[];
+/**
+ * The straight stretches of a route as arc-length intervals, each kept `clear`
+ * of the corners at its ends (and `end` of the route's own ends).
+ */
+export declare function straights(points: Pt[], clear: number, end?: number): [number, number][];
+/**
+ * The nearest arc length to `s` that sits on a straight stretch, clear of the
+ * bends (handles and toggles never sit in a corner). Where no stretch is long
+ * enough, the middle of the longest segment.
+ */
+export declare function clearOfBends(points: Pt[], s: number, clear: number, end?: number): number;
+/** The straight stretch (with `clear` at its corners) that contains arc length `s`. */
+export declare function stretchAt(points: Pt[], s: number, clear: number, end?: number): [number, number];
+/**
+ * Turn short S-jogs (a sidestep between two runs in the same direction,
+ * shorter than `min`) into a gentle diagonal: a wide ribbon cannot take two
+ * right angles in less than its own width without its conductors crossing.
+ */
+export declare function easeJogs(points: Pt[], min: number): Pt[];
+/**
+ * A closed outline around every sample (dilated by `pad`), traced on a 2 px
+ * raster and smoothed: the harness region, tight to what runs through it.
+ */
+export declare function regionOutline(samples: Pt[], pad: number): string;
+/** A stretch of a line at a constant offset from the centre line, between arc lengths a and b. */
+export interface Plateau {
+    o: number;
+    a: number;
+    b: number;
+}
+/**
+ * A line that steps between offsets from the centre line: it runs each
+ * plateau parallel to the route and curves smoothly from one to the next over
+ * the gap between them (b of one to a of the next). Consecutive plateaus at
+ * the same offset join straight through. The building block of every
+ * breakout: a lane leaving its parent line, and a conductor stepping out
+ * level by level.
+ */
+export declare function stepped(points: Pt[], plateaus: Plateau[], radius?: number): {
+    d: string;
+    samples: Pt[];
+};