@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.1

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

@@ -0,0 +1,173 @@
+/**
+ * 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 "Harnesses & links" that holds the harnesses, cables and 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 the
+ * harnesses and links (harnesses, cables and fastener stacks) folded into one
+ * group row at the bottom, `WIRING_PATH`. With `level` (the instance path of
+ * the level on screen, "" for the root), the group holds only that level's own
+ * harnesses, not those of the modules inside it: they show once that module is
+ * the level. Without `level`, every harness, wherever it sits, each with the
+ * module it belongs to. Harnesses never show in the structure. Without any for
+ * the group, the structure alone.
+ */
+export declare function groupWiring(nodes: readonly HierarchyNode[], level?: string): 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/level.d.ts

@@ -0,0 +1,7 @@
+import type { ViewNode } from "./types";
+/**
+ * The modules a level draws: its nodes less what is not a module of its own
+ * (the drilled-into module's boundary ports, a board's net junctions and
+ * their taps). A level with none is empty, whatever ports it shows.
+ */
+export declare function levelModules(nodes: readonly ViewNode[]): ViewNode[];

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;

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

@@ -0,0 +1,79 @@
+/**
+ * Standard outputs (PB-823): the files a capability provider exports for a
+ * custom module, which the viewer reads as ordinary artifacts. It finds them
+ * by their fixed file names (protoboard-cli docs/specs/tool-integrations.md
+ * §8) and never by the tool that wrote them:
+ *
+ *   circuit  board.glb, board.manifest.json, bom.csv, pnp.csv, netlist.json,
+ *            and the drawings schematic.svg, pcb-top.svg, pcb-bottom.svg
+ *   cad      body.glb, body.manifest.json, and print/cut exports (.stl, .3mf, .dxf)
+ *
+ * PCB drawings are in board millimetres: one SVG user unit is 1 mm, the top
+ * view draws board (x, y) at (x, −y), and the bottom view, seen from below,
+ * at (−x, −y), with (x, y) as in pnp.csv and the geometry manifest. That is
+ * what lets the viewer mark a component on them from its pick-and-place row.
+ * A drawing whose viewBox does not hold the placed components is shown
+ * without marks.
+ */
+import type { ArtifactDef, ModuleDef } from "@deltarobotics/uhd";
+import type { GeometryManifest } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+export interface CircuitOutputs {
+    glb?: ArtifactDef;
+    manifest?: ArtifactDef;
+    bom?: ArtifactDef;
+    pnp?: ArtifactDef;
+    netlist?: ArtifactDef;
+    schematic?: ArtifactDef;
+    top?: ArtifactDef;
+    bottom?: ArtifactDef;
+}
+export interface CadOutputs {
+    glb?: ArtifactDef;
+    manifest?: ArtifactDef;
+    /** Manufacturing exports: STL, 3MF, DXF. */
+    exports: ArtifactDef[];
+}
+/** A module's circuit standard outputs, by file name; undefined when it has none of them. */
+export declare function circuitOutputs(def: ModuleDef | undefined): CircuitOutputs | undefined;
+/** A module's cad standard outputs, by file name; undefined when it has none of them. */
+export declare function cadOutputs(def: ModuleDef | undefined): CadOutputs | undefined;
+/** Standard output drawings are views of the board, not pictures of the part: never its thumbnail. */
+export declare const isBoardDrawing: (a: ArtifactDef) => boolean;
+/** RFC 4180 CSV with a header row, as rows of named fields. */
+export declare function parseCsv(text: string): Record<string, string>[];
+export interface PnpRow {
+    instance: string;
+    x: number;
+    y: number;
+    rotation: number;
+    side: "top" | "bottom";
+}
+/** Pick-and-place rows (`instance`, `x_mm`, `y_mm`, `rotation_deg`, `side`); rows that do not parse are left out. */
+export declare function parsePnp(text: string): PnpRow[];
+/** Where a component sits on the board: a rectangle in board millimetres. */
+export interface Footprint {
+    instance: string;
+    side: "top" | "bottom";
+    /** Centre (board mm). */
+    x: number;
+    y: number;
+    /** Size along board x and y, after rotation. */
+    w: number;
+    h: number;
+    /** Where the size came from: the part's package facts, or the manifest feature's area. */
+    size: "package" | "manifest" | "unknown";
+}
+/**
+ * Every placed component's rectangle: its pick-and-place position, sized by
+ * the part's package (length × width, turned by the row's rotation), else by
+ * the manifest feature named by its instance path (a square of its area),
+ * else a 1 mm square.
+ */
+export declare function footprints(board: ModuleDef, lookup: ModuleLookup, pnp: PnpRow[], manifest?: GeometryManifest): Footprint[];
+/** Board millimetres → drawing units for one side (the convention above). */
+export declare const toDrawing: (side: "top" | "bottom", x: number, y: number) => [number, number];
+/** Whether a drawing's viewBox holds every component placed on its side (else its marks would be wrong). */
+export declare function drawingFits(viewBox: [number, number, number, number], side: "top" | "bottom", fps: Footprint[]): boolean;
+/** The component under a point of a drawing, smallest first (a resistor under a chip's corner wins). */
+export declare function footprintAt(side: "top" | "bottom", fps: Footprint[], dx: number, dy: number, slack?: number): Footprint | undefined;

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

@@ -0,0 +1,184 @@
+/**
+ * A module's interfaces as the inspector's slot cards (PB-1042, design A with
+ * expandable cards, 2026-10-21): what each interface is (its kind, protocol,
+ * role and pins), what it is linked to and through which harness, and, for
+ * the card opened, its pin mapping, its stated parameters, its links and the
+ * links derived over them with their state, its findings, its notes and
+ * assumptions, and the sources it cites. Plain data from the view model and
+ * the definitions; nothing here draws.
+ */
+import type { InterfaceDef, ModuleDef } from "@deltarobotics/uhd";
+import type { ViewModel, ViewNode, ViewPort } from "./types";
+export type SlotKind = "power" | "signal" | "mechanical";
+/** A link's state in the inspector's words: a stored link is configured, a derived one compatible. */
+export type SlotState = "configured" | "compatible" | "warning" | "incompatible" | "unconfigured";
+/** One pin or slot of the interface, the leaf it binds, and what it meets on the other side. */
+export interface SlotPin {
+    /** The pin or slot as the board names it ("RX2", "BAT+"). */
+    pin: string;
+    /** The leaf interface it binds on this module ("uart2_rx"), when it is not the pin itself. */
+    leaf?: string;
+    /** `←` into this module, `→` out of it, `—` a shared return (ground), `↔` both or not known. */
+    dir: "←" | "→" | "—" | "↔";
+    /** The pin it meets on the other side, and that module's name. */
+    other?: string;
+    otherModule?: string;
+}
+export interface SlotParam {
+    label: string;
+    value: string;
+}
+export interface SlotLink {
+    /** The link's id as its module declares it ("rx_pads"), or a derived link's name. */
+    label: string;
+    /** Its name as declared ("Receiver wires on the FC"). */
+    name?: string;
+    /** What to select in the viewer for it: a canonical id on the level shown. */
+    select: string;
+    /** The harness or cable it runs through. */
+    via?: string;
+    state: SlotState;
+    /** A link UHD derives over this one (through a cable's conductors, over a net). */
+    derived?: boolean;
+    /** The finding messages the viewer's checks put on it. */
+    diagnostics: string[];
+}
+export interface SlotFinding {
+    /** The host's key for it, when the host gave the finding (its Locate). */
+    key?: string;
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+}
+export interface SlotNote {
+    /** What the trait is ("Usage note", "Assumption", "Data gap"). */
+    label: string;
+    text: string;
+    /** An `assumption` trait, or a relation stated as assumed: marked as such. */
+    assumption?: boolean;
+}
+export interface SlotSource {
+    label: string;
+    url: string;
+}
+export interface InterfaceSlot {
+    /** The port's id on the module. */
+    id: string;
+    name: string;
+    kind: SlotKind;
+    /** "UART · CRSF", "Power in", "USB". */
+    protocol?: string;
+    /** "host", "sink", "source", "device". */
+    role?: string;
+    /** Its pins, as chips. */
+    pins: string[];
+    /** The modules it is linked to, each with the harness the link runs through. */
+    linked: {
+        module: string;
+        via?: string;
+    }[];
+    /** Linked to nothing, and not part of an interface that is. */
+    open: boolean;
+    /** Linked through another interface of the module that binds it (an exported pad inside a linked pad group). */
+    usedBy?: string;
+    /** Exported to the boundary of the module it is in, by that name: linked from outside, not open. */
+    exportedAs?: string;
+    /** A pin bound into another interface of the module (a UART's RX inside its pad group), by that one's name: not on the outline, not linked on its own. */
+    partOf?: string;
+    /** The worst state of its links. */
+    state?: SlotState;
+    pinMap: SlotPin[];
+    params: SlotParam[];
+    links: SlotLink[];
+    findings: SlotFinding[];
+    notes: SlotNote[];
+    sources: SlotSource[];
+    /** Canonical refs of the interface and its links, for findings and Locate (`stack:rx_fc_pads`, `rx_pads`). */
+    refs: string[];
+    /** A card for several alike interfaces (Motor pads ×4): their ids. */
+    members?: string[];
+    /** What such a card is linked to, said once ("4 arms" via "Motor phase leads"). */
+    together?: {
+        module: string;
+        via?: string;
+    };
+}
+/** A finding the host knows about, with the canonical ids it is about (links as the viewer selects them, interfaces as `path:id`). */
+export interface HostFinding {
+    key: string;
+    code: string;
+    message: string;
+    severity: "error" | "warning" | "info";
+    refs: string[];
+}
+export interface SlotOptions {
+    /** Definitions by id: the module's own, its children's (leaves bound by its pad groups) and the other ends'. */
+    lookup: (id: string) => ModuleDef | undefined;
+    /** The level the view model is of, from the root (canonical ids are joined to it). */
+    drill?: string[];
+    /** Names as written in the model, by node id on the level (the view model's labels are upper case). */
+    names?: Map<string, string>;
+    /** Link names as declared, by link id on the level. */
+    linkNames?: Map<string, string>;
+    /** Findings of the host (with their keys) or of the viewer's own checks. */
+    findings?: HostFinding[];
+}
+/** "max_current" → "Max current", "rx_fc_pads" → "RX FC pads". */
+export declare function humanize(id: string): string;
+/** "BATTERY LEAD" → "Battery lead": a label the view model upper-cased, back in sentence case. */
+export declare function sentence(label: string): string;
+/** A parameter with its unit: "5 V", "6–30 V", "2–6" (dimensionless). */
+export declare function paramValue(p: {
+    value?: number;
+    unit?: string;
+    range?: [number, number];
+}): string | undefined;
+/** An interface by id: the module's own, an export's child interface, or a leaf of a child (one or two levels down). */
+export declare function findInterface(def: ModuleDef | undefined, id: string, lookup: SlotOptions["lookup"], depth?: number): InterfaceDef | undefined;
+/** Which way a pin faces, from its leaf's roles, else from its name. */
+export declare function direction(leaf: InterfaceDef | undefined, name: string): SlotPin["dir"];
+/** Power (red), signal (blue) or mechanical (grey): the slot glyph's colour. */
+export declare function slotKind(port: ViewPort, leaves: (InterfaceDef | undefined)[], lanes: string[]): SlotKind;
+/** "dolphinrc.com · …e-165929bb5a.pdf": where a source is, short. */
+export declare function sourceLabel(url: string): string;
+/** Every interface of the node as a slot card, linked ones first, then open ones, then those used through another. */
+export declare function interfaceSlots(node: ViewNode, vm: ViewModel, opts: SlotOptions): InterfaceSlot[];
+/**
+ * Interfaces that differ only by a number (Motor 1 pads … Motor 4 pads), alike in kind, protocol and state of
+ * linking, as one card: "Motor pads ×4", its pins and its links those of every member. Three or more.
+ */
+export declare function groupSlots(slots: InterfaceSlot[]): InterfaceSlot[];
+/** The Interfaces section's header: "6 linked · 1 open", counting each interface of a grouped card. */
+export declare function slotSummary(slots: InterfaceSlot[]): {
+    total: number;
+    linked: number;
+    open: number;
+    used: number;
+    text: string;
+};
+/**
+ * The viewer's own findings as host findings: UHD's checks of the level and
+ * the bundle producer's, each with the canonical ids it is about (links
+ * without their `link:` prefix, re-based onto the root).
+ */
+export declare function checkFindings(checks: {
+    id: string;
+    rule: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    refs: string[];
+    scope?: string;
+}[], producer?: {
+    code: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    entity?: {
+        kind: string;
+        id: string;
+    };
+}[]): HostFinding[];
+/** Names as written, by node id on a level (the view model's labels are upper case), and its links' names by id. */
+export declare function levelNames(vm: ViewModel, level: ModuleDef | undefined, lookup: (id: string) => ModuleDef | undefined): {
+    names: Map<string, string>;
+    linkNames: Map<string, string>;
+};