@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.0

package/dist/components/types/uhd-viewer/src/layout/router.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Grid router (PB-803, design D12): orthogonal routes on the 16 px grid.
+ *
+ * A* over grid cells with a direction in the state. It avoids module cards,
+ * penalises bends and crossings, and keeps parallel runs one grid step apart
+ * by charging for cells another route already runs along. Pinned waypoints
+ * (dragged by the user, saved in the display file) are visited in order; the
+ * bends it chooses itself are the automatic waypoints.
+ */
+import type { Pt, Side } from "../canvas/routing";
+export declare const GRID = 16;
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare const snap: (v: number) => number;
+export declare class GridRouter {
+    private x0;
+    private y0;
+    private W;
+    private H;
+    private blocked;
+    /** Cells used by earlier routes: bit 1 horizontal run, bit 2 vertical run. */
+    private used;
+    /** Search state, allocated once and reused: a state is valid when its stamp is the current search's. */
+    private g;
+    private prev;
+    private stamp;
+    private gen;
+    private thorough;
+    /**
+     * `thorough`: a search that runs out of its budget is retried over the whole grid (off while
+     * dragging, where a frame cannot wait for it).
+     */
+    constructor(obstacles: Rect[], extra?: Pt[], margin?: number, thorough?: boolean);
+    private idx;
+    /**
+     * Route from a port (on `fromSide` of its card) to another port, through
+     * `pins` in order. Returns the polyline in canvas coordinates. With
+     * `within`, the route stays inside that rectangle (a link between two
+     * modules of a container expanded in place never leaves the container);
+     * where no such route exists it is routed without the limit.
+     */
+    route(from: Pt, fromSide: Side, to: Pt, toSide: Side, pins?: Pt[], within?: Rect): Pt[];
+    /** The cells a search may use, in grid coordinates (a container's inside), when a route is kept within one. */
+    private region;
+    /** One routing attempt; `strict` gives up (undefined, nothing marked) where a leg finds no way instead of jogging straight. */
+    private routeOnce;
+    private search;
+    /** Treat an existing route (canvas coordinates, axis-aligned) as occupied, as if it had just been routed. */
+    occupy(points: Pt[]): void;
+    private mark;
+}

package/dist/components/types/uhd-viewer/src/layout/taps.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rail taps (PB-873): a supply rail drawn the way a schematic draws it.
+ *
+ * A rail joins most of a board (a 3V3 rail reaches 15–20 parts). Drawn as one
+ * junction it pulls a line from every corner of the sheet. Drawn as a net
+ * label at each place it is used, it reads at a glance: here the rail is
+ * split into taps, one per cluster of parts (a part and the passives that
+ * serve it, board-layout.ts), each joined only to the members of its cluster.
+ * The taps carry the net's name and colour; the one with the most members
+ * keeps the net's id, the others are `<net>~<cluster>` with `tapOf` set.
+ *
+ * Only the drawing changes: the inspector, the hierarchy and the findings
+ * read the level's view model, where the net is one node.
+ */
+import type { ViewModel, ViewNode } from "../model/types";
+/** A power net with at least this many members is drawn as taps. */
+export declare const RAIL_TAP_MIN = 5;
+export declare function tapRails(vm: ViewModel): ViewModel;
+/** The node a selection names for a drawn node: a tap's net. */
+export declare const selectionId: (node: ViewNode | undefined, id: string) => string;

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

@@ -0,0 +1,129 @@
+/**
+ * A definition's artifacts as cards: every artifact is one card with a kind
+ * (image, 3D model, schematic, PCB, datasheet, document, …), a title, where
+ * it comes from (a file, or the host of its URL) and, where it has one, a
+ * picture to show. No React here: the inspector draws the cards
+ * (chrome/ArtifactCards.tsx), a host may read the same list.
+ */
+import type { ArtifactDef, ModuleDef } from "@deltarobotics/uhd";
+import type { ArtifactResolver } from "../api";
+export type ArtifactKind = "image" | "model" | "schematic" | "pcb" | "drawing" | "datasheet" | "document" | "source" | "firmware" | "data" | "evidence";
+/** The sections cards are shown in, in this order. */
+export type ArtifactGroup = "images" | "models" | "board" | "datasheets" | "documents" | "evidence" | "design" | "data";
+export declare const ARTIFACT_GROUPS: {
+    id: ArtifactGroup;
+    title: string;
+}[];
+/** What a card shows above its title: a picture, or a model a host may draw small. */
+export type ArtifactPreview = {
+    kind: "image";
+    src: string;
+} | {
+    kind: "model";
+    src: string;
+};
+export interface ArtifactCardModel {
+    /** Unique among a definition's cards. */
+    key: string;
+    defId: string;
+    /** The artifact's id (absent for a card that is not an artifact of the definition: an evidence source). */
+    artifactId?: string;
+    title: string;
+    kind: ArtifactKind;
+    group: ArtifactGroup;
+    /** The kind in words: "Datasheet", "STEP model", "PCB top". */
+    kindLabel: string;
+    /** The file format, upper case: "PDF", "STEP", "GLB". */
+    format?: string;
+    /** Where it comes from, short: a URL's host, a file's name. */
+    source?: string;
+    /** More about the source: its authority and when it was fetched ("manufacturer · fetched 2026-10-03"). */
+    sourceNote?: string;
+    /** The whole URL or path, for the tooltip. */
+    location?: string;
+    /** What a click opens when no host takes artifacts. */
+    href?: string;
+    /** Lucide icon name, drawn when there is no picture. */
+    icon: string;
+    preview?: ArtifactPreview;
+    /** The artifact is a web address, not a file of the project. */
+    remote: boolean;
+    description?: string;
+    /** The same model in other formats (a STEP and the GLB exported with it): one card, each format a way to open it. */
+    also?: {
+        artifactId: string;
+        format?: string;
+        href?: string;
+    }[];
+}
+/** An evidence source row (sources.json), as far as cards need it. */
+export interface ArtifactSourceRow {
+    id: string;
+    title: string;
+    url: string;
+    type?: string;
+    authority?: string;
+    fetched_at?: string;
+}
+export interface ArtifactCardOptions {
+    /**
+     * A picture for an artifact that is not an image itself (a model's exported
+     * preview, or the model for the host to draw small). Not given: such cards
+     * show their icon.
+     */
+    previewFor?: (def: ModuleDef, artifact: ArtifactDef) => ArtifactPreview | undefined;
+    /** Load pictures from web addresses (default true). A host that loads only its own files turns it off: those cards show their icon. */
+    remoteImages?: boolean;
+    /** The definition's evidence sources: an artifact with the same URL says its authority and when it was fetched; `evidence: true` lists the others as cards of their own. */
+    sources?: ArtifactSourceRow[];
+    evidence?: boolean;
+    /** Artifacts to leave out (already shown another way). */
+    skip?: (artifact: ArtifactDef) => boolean;
+    /**
+     * Keep a part's internal geometry: the per-interface models its mates are computed from (role `interface`),
+     * which a module's cards leave out (QA B2: 17 "interface geometry" GLBs on a flight controller). An
+     * interface's own card asks for them.
+     */
+    internal?: boolean;
+    /** One card per model, its formats together (`mergeFormats`; default true). */
+    mergeFormats?: boolean;
+}
+/** An artifact that is a part's internal geometry, not something to open: one interface's mating model. */
+export declare const isInternalArtifact: (a: Pick<ArtifactDef, "role">) => boolean;
+/** A file's or URL's last path segment. */
+export declare const artifactFileName: (a: Pick<ArtifactDef, "filePath" | "url">) => string;
+/** The extension of an artifact's file or URL, lower case (only a short alphanumeric one counts). */
+export declare function artifactExtension(a: Pick<ArtifactDef, "filePath" | "url">): string;
+/** A URL's host without `www.`, or undefined when it is not a URL. */
+export declare function hostOf(url: string | undefined): string | undefined;
+interface Classified {
+    kind: ArtifactKind;
+    group: ArtifactGroup;
+    kindLabel: string;
+    icon: string;
+}
+/** What an artifact is, from its type, role, format and file name. */
+export declare function classifyArtifact(a: ArtifactDef): Classified;
+/** One artifact as a card. */
+export declare function artifactCard(def: ModuleDef, a: ArtifactDef, resolve: ArtifactResolver, options?: ArtifactCardOptions): ArtifactCardModel;
+/** A definition's evidence sources (sources.json), each as a card: its title, what kind of source, its host, its authority and when it was fetched. */
+export declare const evidenceSourceCards: (defId: string, sources: ArtifactSourceRow[]) => ArtifactCardModel[];
+/**
+ * Every artifact of a definition as a card, in the order of the groups; with
+ * `evidence`, the definition's evidence sources that no artifact names follow
+ * as cards too.
+ */
+export declare function artifactCards(def: ModuleDef | undefined, resolve: ArtifactResolver, options?: ArtifactCardOptions): ArtifactCardModel[];
+/**
+ * One card per model (QA B2): models that are one file in several formats (`body.step` and `body.glb`, beside
+ * each other) are one card, the first's (a STEP before its GLB), with every format named and the others in
+ * `also`. Its title loses a "(STEP)" that named the format.
+ */
+export declare function mergeFormats(cards: ArtifactCardModel[]): ArtifactCardModel[];
+/** Cards by group, in the groups' order; empty groups are left out. */
+export declare function groupArtifactCards(cards: ArtifactCardModel[]): {
+    id: ArtifactGroup;
+    title: string;
+    cards: ArtifactCardModel[];
+}[];
+export {};

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

@@ -0,0 +1,38 @@
+import type { LinkState } from "./types";
+/**
+ * Interface/harness classification (design decision D7): the rule that
+ * colours ports and links. Domain is the default.
+ */
+export type Classification = "domain" | "drc" | "signal";
+export declare const CLASSIFICATIONS: {
+    id: Classification;
+    label: string;
+}[];
+export interface Colorable {
+    domain: string;
+    protocol: string;
+    state?: LinkState;
+}
+export declare function colorFor(item: Colorable, mode: Classification): string;
+/** Items outside the classification's focus are faded (signal mode shows electrical only). */
+export declare function isFaded(item: Colorable, mode: Classification): boolean;
+/** One entry of a classification's legend. `key` is what `classKey` gives the items it stands for. */
+export interface LegendEntry {
+    key: string;
+    label: string;
+    color: string;
+}
+/** The legend entry an item belongs to in a classification (the key of its colour). */
+export declare function classKey(item: Colorable, mode: Classification): string;
+/**
+ * What the colours of a classification mean. With `present` (the keys drawn
+ * on the level, `presentKeys`), the entries the fixed list leaves out (SPI,
+ * CAN, a domain of its own…) are added where the level has them, so every
+ * colour on screen has an entry to read and to isolate.
+ */
+export declare function legendFor(mode: Classification, present?: ReadonlySet<string>): LegendEntry[];
+/** Signal-type colour: one table for links, lanes and conductors ("uart_tx" is a UART). */
+declare function signalColor(protocol: string): string;
+/** Colour of one conductor in signal mode (the same table as links and lanes). */
+export declare const conductorColor: typeof signalColor;
+export {};

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

@@ -0,0 +1,27 @@
+/**
+ * The system checks the viewer runs itself (PB-823).
+ *
+ * UHD derives links per module: a parent does not see through a child
+ * board's nets (docs/boards-and-nets.md, "Limits"). So the root is checked,
+ * and so is every module below it that declares nets (a board), on its own.
+ * A board's findings are re-based onto the root: refs and ids carry the
+ * board's instance path (`board/u2:pin_14`, `link:board/<id>`, `board:sda`),
+ * and `scope` names the board, so the checks panel can say where a finding
+ * is and the diagram can overlay it when that board is drilled into.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+import { type SystemDiagnostic } from "@deltarobotics/uhd";
+export interface ScopedDiagnostic extends SystemDiagnostic {
+    /** Instance path of the module that was checked ("" for the root). */
+    scope: string;
+}
+/** A canonical path below `scope`, re-based onto the root. */
+export declare function rebase(ref: string, scope: string): string;
+/** Instance paths of every module below `root` that declares nets, depth first. */
+export declare function boardsBelow(root: ModuleDef, lookup: ModuleLookup): {
+    path: string;
+    def: ModuleDef;
+}[];
+/** The root's findings, then each board's, re-based onto the root. */
+export declare function systemDiagnostics(root: ModuleDef, lookup: ModuleLookup): ScopedDiagnostic[];

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

@@ -0,0 +1,63 @@
+/**
+ * Evidence for a part: its sources.json and verification.json, when they are
+ * registered (registerEvidenceFiles; nothing does yet), plus the evidence
+ * traits on its definition.
+ *
+ * The traits come with the bundle. The two files do not (yet): UHD has no
+ * part library to read them from, so without a host that supplies them the
+ * viewer shows the traits only.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+export interface SourceRow {
+    id: string;
+    title: string;
+    url: string;
+    type: string;
+    authority: string;
+    supports?: string[];
+    fetched_at?: string;
+}
+export interface Verification {
+    audit: {
+        checked: number;
+        confirmed: number;
+        wrong: number;
+        unsupported: number;
+    } | null;
+    repairs: string | null;
+    assumptions: unknown[];
+    data_gaps: unknown[];
+    vocabulary_gaps: unknown[];
+    recorded_at: string;
+}
+/** Evidence files by part id (definition id). */
+export declare function registerEvidenceFiles(files: {
+    sources: Record<string, SourceRow[]>;
+    verification: Record<string, Verification>;
+}): void;
+export interface Evidence {
+    /** Whether sources.json / verification.json were available at all (false: the audit state is unknown). */
+    filesKnown: boolean;
+    sources: SourceRow[];
+    verification?: Verification;
+    performance: {
+        kind: string;
+        facts: [string, string][];
+    }[];
+    assumptions: {
+        field: string;
+        value?: string;
+        reason?: string;
+    }[];
+    discrepancies: {
+        field: string;
+        resolution?: string;
+    }[];
+    gaps: string[];
+}
+/** A definition's evidence files as a host gives them (`files`), else as registered. */
+export interface EvidenceFiles {
+    sources?: SourceRow[];
+    verification?: Verification;
+}
+export declare function evidenceFor(def: ModuleDef | undefined, files?: EvidenceFiles): Evidence | undefined;

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

@@ -0,0 +1,57 @@
+/**
+ * Adapter: UHD system ModuleDef → neutral view model.
+ *
+ * A level shows the children of one module. Children that have children of
+ * their own are drawn expanded in place when listed in `expanded` (their
+ * boundary ports are exports, joined to the inner ports by pass-through
+ * lines); otherwise they are drawn as a single card with boundary ports.
+ * Harness children (kind "harness") become harness nodes, and every link
+ * they carry is drawn in two segments through them. System diagnostics
+ * (checkSystem) are overlaid onto link state for DRC colouring.
+ */
+import type { ChildLink, ModuleDef } from "@deltarobotics/uhd";
+import { type LinkResult, type ModuleLookup } from "@deltarobotics/uhd";
+import type { SystemDiagnostic } from "@deltarobotics/uhd";
+import type { ViewLink, ViewModel } from "./types";
+/** Link ids whose child links are stored overrides. */
+type Overrides = Record<string, ChildLink[]>;
+export interface LevelLinks {
+    links: ViewLink[];
+    /** Harness children drawn as regions on links, not as nodes. */
+    regionHarnesses: Set<string>;
+    /** Stored or derived link id → the view link that draws it (for diagnostics). */
+    owners: Map<string, string>;
+    /** Every link UHD derives at this level (through cables and over nets). */
+    derived: LinkResult[];
+}
+/**
+ * The links of one level (PB-803/805). A harness with exactly two connector
+ * ends becomes one link from part to part with the harness as a region along
+ * it; its lanes are the links derived through its conductors and its
+ * conductors are the mated positions. Logical links that name a harness get
+ * the same region. Anything else keeps its own line.
+ */
+export declare function levelLinks(def: ModuleDef, results: LinkResult[], lookup: ModuleLookup, prefix: string, overrides: Overrides | undefined): LevelLinks;
+export interface BuildOptions {
+    /** Child ids (at this level) drawn expanded in place. */
+    expanded: Set<string>;
+    /** Stored child-link overrides keyed by link id (top level). */
+    overrides?: Overrides;
+    /**
+     * System diagnostics to overlay on link state. Refs are relative to the
+     * root; findings of a board checked on its own (see App) carry its path
+     * (`link:board/<id>`), so they overlay when that board is drilled into.
+     */
+    diagnostics?: SystemDiagnostic[];
+    /** Draw ground nets as junctions with wires (GND wires on) rather than as ground symbols. */
+    grounds?: boolean;
+}
+/** Apply child-link overrides to a module's stored links. */
+export declare function withOverrides(def: ModuleDef, overrides: Overrides | undefined): ModuleDef;
+/** Descend `drill` child ids from the root to find the module shown at this level. */
+export declare function levelModule(root: ModuleDef, drill: string[], lookup: ModuleLookup): {
+    def: ModuleDef;
+    path: ViewModel["path"];
+};
+export declare function buildView(root: ModuleDef, lookup: ModuleLookup, drill: string[], opts: BuildOptions): ViewModel;
+export {};

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

@@ -0,0 +1,169 @@
+/**
+ * The hierarchy panel's model (PB-1042): the whole module tree of a system,
+ * every level at once (the root, its sub-modules, their parts and harnesses),
+ * with what each row shows (an icon by kind, the host's part mark, the worst
+ * finding here or below), the filter, the rows on screen, the keyboard, and
+ * how a row maps to the diagram's level and selection. Pure functions, so they
+ * test without a page; viewer/hierarchy.tsx draws them.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+import type { UhdBundleDiagnostic } from "@deltarobotics/uhd";
+import type { NodeMark } from "../api";
+import type { ScopedDiagnostic } from "./diagnostics";
+import { type LevelSelection } from "../host/targets";
+/** What a row is: the same kinds as a host's own module tree. */
+export type HierarchyKind = "system" | "assembly" | "group" | "part" | "board" | "enclosure" | "structure" | "harness" | "fasteners";
+export type Severity = "error" | "warning" | "info";
+export interface Findings {
+    error: number;
+    warning: number;
+    info: number;
+}
+export interface HierarchyNode {
+    /** Instance path from the root ("" is the root). */
+    path: string;
+    /** The parent's path; undefined for the root. */
+    parent?: string;
+    label: string;
+    defId: string;
+    /** The definition's own name, when the instance is named otherwise ("FB upper" is a "Resistor 1 MΩ"). */
+    defName?: string;
+    kind: HierarchyKind;
+    /** A Lucide icon name for the kind. */
+    icon: string;
+    depth: number;
+    quantity?: number;
+    /** The host's mark for the definition (a part's status), as the diagram's dot shows it. */
+    mark?: NodeMark;
+    /** The bundle names the definition and does not hold it: drawn as a placeholder. */
+    missing?: boolean;
+    /** Findings on this module itself. */
+    findings: Findings;
+    /** The worst finding here or below. */
+    worst?: Severity;
+    /** The module has a level of its own (a module with children; not a harness). */
+    drillable: boolean;
+    /** A row of the panel's own that only holds others (`WIRING_PATH`): no module, nothing to select. */
+    group?: boolean;
+    /** In the wiring group: the module it belongs to ("Front-right arm"), since four "Prop nut" rows read alike. */
+    where?: string;
+    children: HierarchyNode[];
+}
+/** Icons by kind (Lucide names), matching a host tree's: a board, a package, a chip, a plug. */
+export declare const KIND_ICON: Record<HierarchyKind, string>;
+/** What a kind is called (tooltips, the accessible description). */
+export declare const KIND_LABEL: Record<HierarchyKind, string>;
+/** A module that stands for a part nobody has chosen yet (the host marks it with a ring). */
+export declare const BLANK_ICON = "circle-dashed";
+/** What kind of module a definition is, from what the bundle says (its UHD kind, nets, children, categories). */
+export declare function kindOf(def: ModuleDef | undefined, isRoot: boolean): HierarchyKind;
+export interface HierarchyOptions {
+    /** The host's marks by definition id (`ViewerOptions.nodeMarks`). */
+    marks?: Record<string, NodeMark>;
+    /** The viewer's own checks (systemDiagnostics). */
+    diagnostics?: readonly ScopedDiagnostic[];
+    /** The producer's and the host's findings. */
+    hostDiagnostics?: readonly UhdBundleDiagnostic[];
+    /** Whether the definition is a placeholder for one the bundle lacks. */
+    isMissing?: (def: ModuleDef) => boolean;
+}
+/** The module tree from the root: `[root]`. A definition that names itself further down stops there. */
+export declare function buildHierarchy(root: ModuleDef, lookup: ModuleLookup, options?: HierarchyOptions): HierarchyNode[];
+/** The module a canonical ref names: `board/u2:pin_14` → `board/u2`, `link:a/b/l1` → `a/b`, `:sda` on a scope → the scope. */
+export declare function modulePart(ref: string, scope: string): string;
+export declare function walkHierarchy(nodes: readonly HierarchyNode[]): Generator<HierarchyNode>;
+/** Every node by path. */
+export declare const hierarchyIndex: (nodes: readonly HierarchyNode[]) => Map<string, HierarchyNode>;
+/** The paths above `path`, root first ("" for the root itself has none). */
+export declare function ancestorsOf(path: string): string[];
+/**
+ * The tree reduced to the rows that match `text` (every word, in the label,
+ * the definition's name, the instance path, the definition id or the kind;
+ * case-insensitive), with
+ * the modules that lead to them. A matching module keeps its own children.
+ * Returns the reduced tree and the paths to show open.
+ */
+export declare function filterHierarchy(nodes: readonly HierarchyNode[], text: string): {
+    nodes: HierarchyNode[];
+    expanded: Set<string>;
+    matches: Set<string>;
+};
+/** One row on screen. */
+export interface HierarchyRow {
+    node: HierarchyNode;
+    /** 1-based, as `aria-level` takes it. */
+    level: number;
+    /** Has rows below it (open or not). */
+    branch: boolean;
+    open: boolean;
+    /** 1-based place among its siblings, and how many there are (`aria-posinset`, `aria-setsize`). */
+    pos: number;
+    size: number;
+}
+/** The rows on screen: every node whose ancestors are all open. */
+export declare function visibleRows(nodes: readonly HierarchyNode[], expanded: ReadonlySet<string>): HierarchyRow[];
+/** What a key does on the tree: where the focus goes, what opens or closes, and what is asked of the viewer. */
+export interface TreeKeyResult {
+    focus: string;
+    expanded: Set<string>;
+    action?: "select" | "drill";
+}
+/**
+ * The tree's keyboard (WAI-ARIA tree pattern): Up and Down move, Home and End
+ * go to the first and last row; Right opens a closed module, or moves to its
+ * first child; Left closes an open one, or moves to its parent; Enter and
+ * Space select the row (Enter on the row already selected drills into it,
+ * when it has a level of its own); `*` opens every sibling. Undefined: the key
+ * is not the tree's.
+ */
+export declare function treeKey(rows: readonly HierarchyRow[], focus: string, key: string, expanded: ReadonlySet<string>, selected?: string): TreeKeyResult | undefined;
+/** The module path the diagram has selected, from its level and selection; undefined for none, a link or a net. */
+export declare function selectedPath(drill: readonly string[], selection: LevelSelection): string | undefined;
+/**
+ * Where a click on a row takes the diagram: the level that holds the module,
+ * with it selected (the current level, when the module is drawn there; the
+ * root row is the top level with nothing selected).
+ */
+export declare function rowTarget(root: ModuleDef, lookup: ModuleLookup, path: string, current: {
+    drill: string[];
+    expanded: ReadonlySet<string>;
+}): {
+    drill: string[];
+    selection: LevelSelection;
+};
+/** Where drilling into a row takes the diagram: its own level, nothing selected. */
+export declare function drillInto(node: HierarchyNode): {
+    drill: string[];
+    selection: LevelSelection;
+};
+/** The paths to open so that `path` shows: its ancestors. */
+export declare function revealPaths(expanded: ReadonlySet<string>, path: string | undefined): Set<string>;
+/** What the panel keeps per tab: open or folded to its rail, its width, the open modules. */
+export interface HierarchyPanelState {
+    open: boolean;
+    width: number;
+    expanded: string[];
+}
+export declare const HIERARCHY_WIDTH: {
+    readonly min: 180;
+    readonly max: 520;
+    readonly default: 280;
+};
+/** A kept state, checked; anything malformed falls back to the default. */
+export declare function panelState(v: unknown, fallbackOpen?: boolean): HierarchyPanelState;
+export declare const clampWidth: (w: number, room?: number) => number;
+/** The row that holds the wiring and hardware (harnesses, cables, fastener stacks): not a module of the system. */
+export declare const WIRING_PATH = "#wiring";
+/**
+ * The tree as the panel shows it: the system's structure first, and its
+ * wiring and hardware (every harness and fastener stack, wherever it sits)
+ * folded into one group row at the bottom, `WIRING_PATH`. Without any, the
+ * tree as it is.
+ */
+export declare function groupWiring(nodes: readonly HierarchyNode[]): HierarchyNode[];
+/** The marks the tree shows, once each, in the order of their tones: a legend (the first sentence of a mark's label names it). */
+export declare function markLegend(nodes: readonly HierarchyNode[]): {
+    tone: NodeMark["tone"];
+    label: string;
+}[];

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

@@ -0,0 +1,33 @@
+/**
+ * Isolating a legend entry (a signal type, a domain, a DRC state): the links
+ * of that kind stay, with the interfaces and modules they touch; everything
+ * else on the level fades. Pure functions of the level's view model, so the
+ * result follows the model as it rebuilds and the drill level as it changes.
+ */
+import { type Classification } from "./classification";
+import type { ViewLink, ViewModel } from "./types";
+/** What stays at full strength while some legend entries are isolated. */
+export interface Isolation {
+    /** View link ids (`ViewLink.id`: each drawn line). */
+    links: Set<string>;
+    /** Node ids: the ends of those links, the nets of that kind, and the containers that hold either. */
+    nodes: Set<string>;
+    /** Ports as `node|port`: the ends of those links, and ports of that kind on a node that stays. */
+    ports: Set<string>;
+}
+/**
+ * The legend entries a link belongs to: its own and, by signal type or
+ * domain, those of what it carries (a cable with power and a UART is in both;
+ * by DRC state a link has one state, its own).
+ */
+export declare function linkKeys(link: ViewLink, mode: Classification): Set<string>;
+/** Every legend entry the level has something of: its links (and what they carry) and its nets. */
+export declare function presentKeys(vm: ViewModel, mode: Classification): Set<string>;
+/** What stays when `keys` are isolated on the level; null when nothing is isolated. */
+export declare function isolate(vm: ViewModel, mode: Classification, keys: ReadonlySet<string>): Isolation | null;
+/**
+ * A click on a legend entry: it becomes the one isolated; a click on the only
+ * one isolated shows everything again. With `add` (a modifier key) it joins
+ * or leaves the ones held.
+ */
+export declare function toggleIsolated(current: ReadonlySet<string>, key: string, add?: boolean): Set<string>;

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

@@ -0,0 +1,53 @@
+/**
+ * Board nets in the view model (PB-823; UHD docs/boards-and-nets.md).
+ *
+ * A net is a `Net` interface on the board itself (protocol `net`, not
+ * exposed), joined to each pin on it by a stored membership link. Drawing a
+ * line per membership would draw a star of N lines per net, most of them to
+ * the same component; drawing every pair would be worse. Instead:
+ *
+ * - each net is a junction node (`:<net>`; `board:<net>` when the board is
+ *   expanded in place);
+ * - each component on the net gets one port for it, named for the net, and
+ *   one grouped line to the junction whose children are its pins on the net;
+ * - a ground net (a ground pin on it and no supply pin) is drawn as ground
+ *   symbols at its members, like any ground link, unless GND wires are on;
+ * - the functional links UHD derives over the nets (an I2C bus, a supply to
+ *   its loads) are listed by name, and their state is carried by the grouped
+ *   lines they run over, so a `bus_incomplete` or `harness_wiring` finding
+ *   on one turns those lines red, as it does for a cable's lanes.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { LinkResult, ModuleLookup } from "@deltarobotics/uhd";
+import type { ViewDerived, ViewLink, ViewNode, ViewPort } from "./types";
+/** Node id of a net: the canonical path of the net interface (`:<net>`, or `board:<net>` inside an expanded board). */
+export declare const netNodeId: (prefix: string, net: string) => string;
+/** Port id on a component for its connection to a net. */
+export declare const netPortId: (net: string) => string;
+/**
+ * Label of a grouped membership line: the pin's name, or the distinct names
+ * of several ("VDD/VDDIO"), or the first and how many others ("IOVDD +3").
+ */
+export declare function pinsLabel(names: string[]): string;
+export interface LevelNets {
+    /** Junction nodes (ground nets left out unless `grounds`). */
+    nodes: ViewNode[];
+    /** One grouped line per component and net. */
+    links: ViewLink[];
+    /** Ports to add to the component nodes, by node id. */
+    ports: Map<string, ViewPort[]>;
+    derived: ViewDerived[];
+    /** Membership link id (prefixed) → grouped line id. */
+    owners: Map<string, string>;
+    /** Derived link id (prefixed) → grouped line ids it runs over. */
+    derivedOwners: Map<string, string[]>;
+}
+/**
+ * The nets of `def` drawn at a level (`prefix` "" for the level module itself,
+ * `<child>/` for a board expanded in place). `results` are the module's stored
+ * link results, `derived` the links UHD derives from them.
+ */
+export declare function levelNets(def: ModuleDef, results: LinkResult[], derived: LinkResult[], lookup: ModuleLookup, prefix: string, opts: {
+    grounds: boolean;
+    parent?: string;
+}): LevelNets;