@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,162 @@
+/**
+ * How the pointer and the keyboard act on the diagram: which tool is chosen
+ * (select or pan), what a drag on the empty canvas does with it, and the
+ * canvas's keys. No React and no DOM here, so the rules are tested as data.
+ *
+ * - Select (the default): a left-drag on the empty canvas draws a selection
+ *   box; a middle-button drag pans; holding Space makes a left-drag pan,
+ *   also one that starts on a module (modules are not dragged while it is held).
+ * - Pan: a left-drag pans, also over modules (they are not dragged).
+ * - With either tool, a right-drag pans, over the empty canvas, modules and
+ *   links; a right-click that does not move (`rightPress`) opens the menu.
+ * - The wheel and a pinch zoom with either tool.
+ */
+export type CanvasTool = "select" | "pan";
+export interface InteractionState {
+    tool: CanvasTool;
+    /** Space is held: a left-drag pans while it is. */
+    space: boolean;
+}
+export type InteractionAction = {
+    type: "tool";
+    tool: CanvasTool;
+} | {
+    type: "toggle";
+} | {
+    type: "space";
+    down: boolean;
+} | {
+    type: "blur";
+};
+export declare const initialInteraction: InteractionState;
+export declare function interactionReducer(state: InteractionState, action: InteractionAction): InteractionState;
+export interface InteractionProps {
+    /** `true`: every button pans; a list: only these buttons do. */
+    panOnDrag: true | number[];
+    /** A left-drag on the empty canvas draws a selection box. */
+    selectionOnDrag: boolean;
+    nodesDraggable: boolean;
+    /** What the pointer looks like over the empty canvas. */
+    cursor: "default" | "grab";
+}
+/** What React Flow is told for a state: the tool, and Space held over it. */
+export declare function interactionProps(state: InteractionState): InteractionProps;
+/** The right button: a drag with it pans, a click opens the menu. */
+export declare const RIGHT = 2;
+/** How far (px) the pointer may move with the right button down and still be a click. */
+export declare const CLICK_SLOP = 4;
+/** The right button held on the canvas: where it went down, and whether it has become a pan. */
+export interface RightPress {
+    x: number;
+    y: number;
+    panning: boolean;
+}
+export declare const rightPress: (x: number, y: number) => RightPress;
+/**
+ * The press after the pointer moved to (x, y): a pan once it has gone further
+ * than the slop from where it went down, and a pan from then on, also if it
+ * comes back (a drag that returns to its start is still not a click).
+ */
+export declare function rightMove(press: RightPress, x: number, y: number, slop?: number): RightPress;
+/** What letting go of the right button does: open the menu (a click) or nothing more (a pan, which already moved the view). */
+export declare const rightRelease: (press: RightPress) => "menu" | "pan";
+/** The tool toggle's two choices (Lucide icons), each with its key. */
+export declare const TOOL_OPTIONS: readonly [{
+    readonly id: "select";
+    readonly icon: "mouse-pointer-2";
+    readonly label: "Select: drag on the canvas to select several";
+    readonly shortcut: "V";
+}, {
+    readonly id: "pan";
+    readonly icon: "hand";
+    readonly label: "Pan: drag to move the view";
+    readonly shortcut: "H";
+}];
+/** What a key press asks of the canvas. */
+export type CanvasCommand = {
+    type: "tool";
+    tool: CanvasTool;
+} | {
+    type: "selectAll";
+} | {
+    type: "escape";
+} | {
+    type: "fit";
+} | {
+    type: "zoom";
+    by: "in" | "out" | "reset";
+} | {
+    type: "nudge";
+    dx: number;
+    dy: number;
+};
+export interface KeyLike {
+    key: string;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    shiftKey?: boolean;
+    altKey?: boolean;
+}
+/**
+ * The canvas command of a key press, or undefined for a key the canvas
+ * leaves alone. Keys with Ctrl or Cmd other than select-all are the host's
+ * (an editor's own zoom, save, undo); Alt is never taken.
+ */
+export declare function canvasCommand(e: KeyLike, grid?: number): CanvasCommand | undefined;
+/**
+ * Keys typed into a field, or pressed on a control that uses them, are not the
+ * canvas's: a menu, a dialog (the legend's popover), and a tree or list that walks its rows with the arrows and
+ * filters as you type (the hierarchy panel). The canvas listens on the window
+ * before them, so without this an arrow on a hierarchy row nudged the selected
+ * module and a letter switched the tool (UI QA phase 3).
+ */
+export declare function typingTarget(target: {
+    closest?: (selector: string) => unknown;
+} | null | undefined): boolean;
+/**
+ * The nodes selected after React Flow's selection changes (a box drag, a
+ * click with Shift, Ctrl or Cmd held, a plain click): what was selected, with
+ * the changes applied, each named by `canonical` (a supply rail's taps are
+ * the rail), once.
+ */
+export declare function applySelectChanges(selected: Iterable<string>, changes: readonly {
+    id: string;
+    selected: boolean;
+}[], canonical?: (id: string) => string): string[];
+export interface Viewport {
+    x: number;
+    y: number;
+    zoom: number;
+}
+export interface FirstViewState {
+    /** The viewport saved for this level (the user's last pan or zoom there). */
+    saved?: Viewport;
+    /** The saved viewport was put back since the canvas mounted. */
+    restored: boolean;
+    /** The user panned or zoomed since the canvas mounted (or a host moved the view to something). */
+    moved: boolean;
+    /** What is drawn: changes when modules come or go. */
+    nodesKey: string;
+    /** What was drawn at the last automatic fit (null: none yet). */
+    fittedKey: string | null;
+    /** The canvas has a size (a tab opened in the background has none yet). */
+    sized: boolean;
+    /** The canvas's size now and at the last automatic fit (`w×h`): a panel docked beside it or folded changes it. */
+    size?: string;
+    fittedSize?: string | null;
+}
+/**
+ * What the canvas does with its view when it opens or its modules change:
+ * a saved viewport is put back, once; with none, the diagram is fitted, and
+ * fitted again when modules come or go or the canvas changes size (a panel
+ * docked beside it opens or folds), until the user moves the view.
+ */
+export declare function firstView(s: FirstViewState): {
+    kind: "restore";
+    viewport: Viewport;
+} | {
+    kind: "fit";
+} | {
+    kind: "keep";
+};
+export declare const validViewport: (v: unknown) => v is Viewport;

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

@@ -0,0 +1,43 @@
+import type { Node, NodeProps } from "@xyflow/react";
+import type { Box, PlacedPort, PortGroup } from "../layout/layout";
+import type { ViewNode } from "../model/types";
+import type { NodeMark } from "../api";
+import { type Classification } from "../model/classification";
+export interface NodeData extends Record<string, unknown> {
+    node: ViewNode;
+    box: Box;
+    ports: PlacedPort[];
+    groups: PortGroup[];
+    mode: Classification;
+    showGrounds: boolean;
+    selectedPorts: Set<string>;
+    /** Ports ("node|port") whose link draws its own pin handle (ribbon mode): no dot. */
+    ribbonPorts?: Set<string>;
+    /** The host's mark for the node's definition: the corner dot takes its tone. */
+    mark?: NodeMark;
+    /** Legend entries are isolated and the node stays: its ports that stay (the others fade). Absent: nothing is isolated. */
+    keptPorts?: Set<string>;
+}
+export type ModuleNodeType = Node<NodeData, "module">;
+export type ContainerNodeType = Node<NodeData, "container">;
+export type SheetNodeType = Node<NodeData, "sheet">;
+export type HarnessNodeType = Node<NodeData, "harness">;
+export type NetNodeType = Node<NodeData, "net">;
+export declare function ModuleNode({ data, selected }: NodeProps<ModuleNodeType>): import("react").JSX.Element;
+export declare function ContainerNode({ data, selected }: NodeProps<ContainerNodeType>): import("react").JSX.Element;
+export declare function SheetNode({ data, selected }: NodeProps<SheetNodeType>): import("react").JSX.Element;
+/** A harness module drawn as the carrier node its links pass through (design D2, board 04). */
+export declare function HarnessNode({ data, selected }: NodeProps<HarnessNodeType>): import("react").JSX.Element;
+/**
+ * A board net (PB-823): a junction that its members' grouped lines meet at.
+ * Its colour is the net's own (power, ground, the bus it carries), its status
+ * the worst of its lines.
+ */
+export declare function NetNode({ data, selected }: NodeProps<NetNodeType>): import("react").JSX.Element;
+export declare const nodeTypes: {
+    module: typeof ModuleNode;
+    container: typeof ContainerNode;
+    sheet: typeof SheetNode;
+    harness: typeof HarnessNode;
+    net: typeof NetNode;
+};

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

@@ -0,0 +1,37 @@
+/**
+ * Bringing a host's selection into view (a host's select, such as a DRC
+ * finding's Locate): where the selection is drawn, and the viewport that shows
+ * it clear of the floating chrome, or none when it is in view already.
+ */
+import type { ComputedLayout } from "../layout/layout";
+import type { ViewModel } from "../model/types";
+/** A selection on the level, as the canvas holds it. */
+export type RevealSelection = {
+    kind: "node" | "link";
+    id: string;
+};
+export type Rect = {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** Where a selection is drawn, in flow coordinates: a node's box, or every line of a link (a derived link: the lines it runs over). */
+export declare function selectionBounds(vm: ViewModel, layout: ComputedLayout, selection: RevealSelection): Rect | undefined;
+/**
+ * The viewport that shows `rect` clear of the floating chrome (the inspector
+ * too, when open), or undefined when it is in view already. It keeps the zoom
+ * and pans, zooming out only as far as the selection needs; never in.
+ */
+export declare function revealViewport(rect: Rect, viewport: {
+    x: number;
+    y: number;
+    zoom: number;
+}, pane: {
+    width: number;
+    height: number;
+}, inspector: boolean, minZoom?: number): {
+    x: number;
+    y: number;
+    zoom: number;
+} | undefined;

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

@@ -0,0 +1,51 @@
+/**
+ * The right button on the diagram: a drag pans the view, a click (the pointer
+ * moved no further than `CLICK_SLOP`) opens the canvas's menu where it was
+ * let go. No DOM here: the canvas feeds it the pointer's events and does what
+ * it returns, so the order browsers send them in is tested as data.
+ *
+ * Browsers send `contextmenu` at different moments: on Linux and macOS when
+ * the button goes down (before anyone knows whether it will be a drag), on
+ * Windows after it comes up. So the canvas never lets the browser's menu (or
+ * a VS Code webview's) open over what has a menu of its own: `contextmenu`
+ * is cancelled, and the menu opens on release, only when the press was a
+ * click. A `contextmenu` with no right press behind it (the keyboard's menu
+ * key, Shift+F10, Ctrl+click on a Mac) opens the menu at once.
+ */
+import { type Viewport } from "./interaction";
+export interface RightDragHost<T> {
+    viewport(): Viewport;
+    setViewport(viewport: Viewport): void;
+    /** A pan by the right button began. */
+    panStart?(): void;
+    /** A pan by the right button ended, at this viewport. */
+    panEnd(viewport: Viewport): void;
+    /** The canvas has a menu of its own for what is at this target (a module, a link, the empty canvas). */
+    hasMenu(target: T): boolean;
+    /** Open the canvas's menu for the target, at the pointer. */
+    openMenu(target: T, x: number, y: number): void;
+    /** The time now (ms); default `performance.now()`. */
+    now?(): number;
+}
+export interface PointerLike<T> {
+    button: number;
+    /** The buttons held (a pointer move): a release the canvas did not see ends the press. */
+    buttons?: number;
+    x: number;
+    y: number;
+    target: T;
+}
+export interface RightDrag<T> {
+    /** A button went down on the canvas: true when it is the right one (the press is the canvas's). */
+    down(e: PointerLike<T>): boolean;
+    /** The pointer moved: true while the press pans. */
+    move(e: Omit<PointerLike<T>, "button" | "target">): boolean;
+    /** A button came up: what the press was, if it was a right one. */
+    up(e: PointerLike<T>): "menu" | "pan" | undefined;
+    /** The browser asks to show its menu: true to cancel it (the canvas has its own, now or on release). */
+    contextMenu(e: Omit<PointerLike<T>, "button">): boolean;
+    /** Forget the press (the window lost focus). */
+    cancel(): void;
+    readonly panning: boolean;
+}
+export declare function createRightDrag<T>(host: RightDragHost<T>): RightDrag<T>;

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

@@ -0,0 +1,28 @@
+/**
+ * Orthogonal link routing with filleted corners (design decision D3).
+ * Pure geometry: no React.
+ */
+export type Side = "left" | "right" | "top" | "bottom";
+export type Pt = [number, number];
+/** Remove duplicate and collinear points. */
+export declare function simplify(points: Pt[]): Pt[];
+/**
+ * Route from a port on `sourceSide` to a port on `targetSide`. Waypoints, when
+ * given, are visited in order; otherwise a 1–2 elbow Manhattan route is used.
+ */
+export declare function route(source: Pt, sourceSide: Side, target: Pt, targetSide: Side, waypoints?: Pt[]): Pt[];
+/** SVG path through `points` with quadratic fillets of radius `r` (or per-corner radii). */
+export declare function filletPath(points: Pt[], r: number | number[]): string;
+export declare function length(points: Pt[]): number;
+/** Point at fraction `t` (0..1) along the polyline. */
+export declare function pointAt(points: Pt[], t: number): Pt;
+/** Fraction along the path of the middle of its longest segment (default label spot). */
+export declare function longestSegmentMid(points: Pt[]): number;
+/**
+ * Offset an orthogonal polyline sideways by `d` (positive = left of travel
+ * direction in screen space). Returns the points and concentric fillet radii.
+ */
+export declare function offsetPolyline(points: Pt[], d: number, r: number): {
+    points: Pt[];
+    radii: number[];
+};

package/dist/components/types/uhd-viewer/src/chrome/ArtifactCards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Artifacts as cards: a picture (the image itself, a model's preview, else
+ * the kind's icon), the title, the kind and where it comes from. A click
+ * opens the artifact: through the host when it takes artifacts, else its URL
+ * in a new tab. Pictures load lazily (only cards scrolled into view); a model
+ * is drawn only when the host gives a drawer for it.
+ *
+ * The grid is a container: two or more cards a row where they fit, and one
+ * card a row, picture at the left, in a narrow panel (the layout is in
+ * styles/ui.css; see there why it is not container-variant utilities).
+ */
+import { type ReactNode } from "react";
+import type { ArtifactCardModel } from "../model/artifacts";
+export interface ArtifactCardProps {
+    card: ArtifactCardModel;
+    /** Shown at the card's top right (a "sample" tag, a state). */
+    badge?: ReactNode;
+}
+/** One artifact: its picture, title, kind and source. */
+export declare function ArtifactCard({ card, badge }: ArtifactCardProps): import("react").JSX.Element;
+/** Cards in a grid that fits its container. */
+export declare function ArtifactGrid({ cards, className }: {
+    cards: ArtifactCardModel[];
+    className?: string;
+}): import("react").JSX.Element | null;
+/** Cards under a small title per group (Images, 3D models, Datasheets, …), each with its count. */
+export declare function ArtifactCards({ cards, className }: {
+    cards: ArtifactCardModel[];
+    className?: string;
+}): import("react").JSX.Element | null;

package/dist/components/types/uhd-viewer/src/chrome/Artifacts.d.ts

@@ -0,0 +1,44 @@
+import type { ArtifactDef, ModuleDef } from "@deltarobotics/uhd";
+import type { Appearance } from "../source/source";
+import type { ArtifactResolver } from "../api";
+export type { ArtifactResolver };
+/**
+ * The library's convention: an image artifact tagged "thumbnail"; failing that
+ * any image (by MIME type or extension), a datasheet's pages last.
+ */
+export declare function thumbnailOf(def: ModuleDef): ArtifactDef | undefined;
+/**
+ * An artifact file row: a link to the file, or, when a host takes artifacts
+ * (`onOpenArtifact`), a request to the host to open it.
+ */
+export declare function ArtifactLink({ defId, artifactId, href, title, children }: {
+    defId: string;
+    artifactId: string;
+    href?: string;
+    title?: string;
+    children: React.ReactNode;
+}): import("react").JSX.Element;
+/**
+ * An assembly (FC + ESC stack, an arm) usually has no CAD of its own: show its
+ * parts' artifacts instead, one part at a time, picked from a row of names.
+ */
+export declare function AssemblyArtifacts({ def, lookup, resolve, appearance, titled, }: {
+    def?: ModuleDef;
+    lookup: (id?: string) => ModuleDef | undefined;
+    resolve: ArtifactResolver;
+    appearance?: Record<string, Appearance>;
+    /** Its own "Artifacts" title (off where a section header says it). */
+    titled?: boolean;
+}): import("react").JSX.Element | null;
+/**
+ * A definition's artifacts: its picture, its body model (turning in a small
+ * 3D preview, unless the host shows models as cards), and every artifact as
+ * a card under its kind. A board's drawings and outputs are left to the
+ * board's own section (BoardViews).
+ */
+export declare function ArtifactsSection({ def, resolve, appearance, titled }: {
+    def?: ModuleDef;
+    resolve: ArtifactResolver;
+    appearance?: Appearance;
+    titled?: boolean;
+}): import("react").JSX.Element | null;

package/dist/components/types/uhd-viewer/src/chrome/BoardInspector.d.ts

@@ -0,0 +1,53 @@
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { ViewDerived, ViewModel, ViewNode } from "../model/types";
+import type { ArtifactResolver } from "../api";
+import type { Selection } from "../canvas/Canvas";
+/** A part's package as the manufacturer states it (UHD `partPackage`), with its body size. */
+export declare function PackageSection({ def, titled }: {
+    def?: ModuleDef;
+    titled?: boolean;
+}): import("react").JSX.Element | null;
+/**
+ * Every pin with a designator, in package order, with the net it is on at
+ * this level (from the grouped membership lines of `node`).
+ */
+export declare function PinTable({ def, node, vm, titled }: {
+    def?: ModuleDef;
+    node: ViewNode;
+    vm: ViewModel;
+    titled?: boolean;
+}): import("react").JSX.Element | null;
+/** Functional links derived over nets, listed by name. */
+export declare function DerivedList({ items, title, onSelect, titled }: {
+    items: ViewDerived[];
+    title: string;
+    onSelect: (s: Selection) => void;
+    titled?: boolean;
+}): import("react").JSX.Element | null;
+/** A net: its voltage, its members and their pins, and the links derived over it. */
+export declare function NetDetails({ node, vm, onSelect, bare }: {
+    node: ViewNode;
+    vm: ViewModel;
+    onSelect: (s: Selection) => void;
+    bare?: boolean;
+}): import("react").JSX.Element;
+/** A link derived over nets, shown by name: its ends, nets, conductors and findings. */
+export declare function DerivedDetails({ d, vm, onSelect, bare }: {
+    d: ViewDerived;
+    vm: ViewModel;
+    onSelect: (s: Selection) => void;
+    bare?: boolean;
+}): import("react").JSX.Element;
+/**
+ * The board's drawings, one tab each. `highlight` is a component instance
+ * (relative to the board) to mark; `onPick` receives the component clicked.
+ */
+export declare function BoardViews({ def, lookup, resolve, highlight, onPick, drawings, }: {
+    /** The drawings with pan and zoom (default). False: the outputs as cards only, nothing fetched. */
+    drawings?: boolean;
+    def: ModuleDef;
+    lookup: (id: string) => ModuleDef | undefined;
+    resolve: ArtifactResolver;
+    highlight?: string;
+    onPick?: (instance: string) => void;
+}): import("react").JSX.Element | null;

package/dist/components/types/uhd-viewer/src/chrome/Chrome.d.ts

@@ -0,0 +1,116 @@
+import type { ChildLink, ModuleDef } from "@deltarobotics/uhd";
+import type { UhdBundleDiagnostic } from "@deltarobotics/uhd";
+import type { ScopedDiagnostic } from "../model/diagnostics";
+import type { ViewLink, ViewModel, ViewNode } from "../model/types";
+import { type ArtifactResolver } from "./Artifacts";
+import type { Appearance } from "../source/source";
+import { type Classification } from "../model/classification";
+import { type HostFinding } from "../model/slots";
+import { type InterfaceCardActions } from "./InterfaceCards";
+import type { Selection } from "../canvas/Canvas";
+export type Panel = "hierarchy" | "checks";
+/** "24 models · 2 docs · 1 evidence": what a definition's artifacts, and its parts', are, by group. */
+export declare function artifactSummary(def: ModuleDef | undefined, lookup: (id?: string) => ModuleDef | undefined): {
+    count: number;
+    text: string;
+};
+export interface NodeDetailsProps {
+    node: ViewNode;
+    vm: ViewModel;
+    mode: Classification;
+    def?: ModuleDef;
+    onDrill: (id: string) => void;
+    onToggleExpand: (id: string) => void;
+    onSelect: (s: Selection) => void;
+    /** Thumbnail and CAD preview. */
+    artifacts?: React.ReactNode;
+    /** The board's drawings: this node's own, or those of the board it sits on, with it marked. */
+    board?: React.ReactNode;
+    /** Ask the host to open the module's source (only when a host takes it). */
+    onOpenSource?: () => void;
+    /** No title and no action buttons: the host draws its own header and actions. */
+    bare?: boolean;
+    /** Definitions by id (the interface cards read the module's children and the other ends). */
+    lookup?: (id?: string) => ModuleDef | undefined;
+    /** The level shown, from the root: canonical ids for findings and Locate. */
+    drill?: string[];
+    /** Names as written, by node id on the level; link names by link id. */
+    names?: Map<string, string>;
+    linkNames?: Map<string, string>;
+    /** Findings to show on the interface cards (the host's, with keys; else the viewer's own checks). */
+    findings?: HostFinding[];
+    /** What the interface cards' actions do. */
+    cardActions?: InterfaceCardActions;
+}
+export declare function NodeDetails(props: NodeDetailsProps): import("react").JSX.Element;
+export declare function LinkDetails({ link, mode, open, onToggle, onPair, bSlots, override, onOverride, harness, derived, onOpenSource, preview, bare, }: {
+    /** No title and no action buttons: the host draws its own header and actions. */
+    bare?: boolean;
+    /** Ask the host to open the source that declares the link (only when a host takes it). */
+    onOpenSource?: () => void;
+    /** The pair the link joins, small (its button opens the pair view). */
+    preview?: React.ReactNode;
+    /** The harness carrying the link: its artifacts (thumbnail, CAD). */
+    harness?: React.ReactNode;
+    /** Functional links that run over this line (a grouped net membership). */
+    derived?: React.ReactNode;
+    link: ViewLink;
+    mode: Classification;
+    open: boolean;
+    onToggle: (id: string) => void;
+    onPair: () => void;
+    /** Child slots on the b side, for remapping. */
+    bSlots: string[];
+    override?: ChildLink[];
+    onOverride?: (childLinks: ChildLink[] | null) => void;
+}): import("react").JSX.Element;
+/** Where to go for a finding: a drill path and what to select there. */
+export interface Goto {
+    drill: string[];
+    selection: Selection;
+}
+declare function InspectorView(props: {
+    className?: string;
+    vm: ViewModel;
+    panel: Panel;
+    onPanel: (p: Panel) => void;
+    selection: Selection;
+    mode: Classification;
+    openLinks: Set<string>;
+    diagnostics: ScopedDiagnostic[];
+    /** Findings from the bundle's producer and the host (UHD's own checks excluded: the viewer runs them). */
+    hostDiagnostics: UhdBundleDiagnostic[];
+    defFor: (defId?: string) => ModuleDef | undefined;
+    /** Artifact URLs (from the bundle source) and per-definition appearance hints, for the previews. */
+    resolveArtifact: ArtifactResolver;
+    appearance?: Record<string, Appearance>;
+    bSlotsFor: (link: ViewLink) => string[];
+    overrides: Record<string, ChildLink[]>;
+    onOverride: (linkId: string, childLinks: ChildLink[] | null) => void;
+    onSelect: (s: Selection) => void;
+    onDrill: (id: string) => void;
+    onToggleLink: (id: string) => void;
+    onToggleExpand: (id: string) => void;
+    onPair: (link: ViewLink) => void;
+    topLevel: boolean;
+    /** The module shown at this level and its drill path (for its board drawings and for findings elsewhere). */
+    levelDef: ModuleDef;
+    drill: string[];
+    onGoto: (g: Goto) => void;
+    /** A module's context menu (when a host takes open actions). */
+    onNodeContext?: (id: string, x: number, y: number) => void;
+}): import("react").JSX.Element;
+export interface NodeMenuItem {
+    label: string;
+    run: () => void;
+}
+/** A small menu at the pointer; any click elsewhere, Escape, or a choice closes it. */
+export declare function NodeMenu({ x, y, items, onClose }: {
+    x: number;
+    y: number;
+    items: NodeMenuItem[];
+    onClose: () => void;
+}): import("react").JSX.Element | null;
+/** Memoised: re-renders only when its props change, not on every frame of a canvas drag. */
+export declare const Inspector: import("react").MemoExoticComponent<typeof InspectorView>;
+export {};

package/dist/components/types/uhd-viewer/src/chrome/Evidence.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Evidence for a part, in the inspector: whether its facts were audited, the
+ * performance its definition states, the assumptions and source conflicts it
+ * records, the open data gaps, and its sources, each a card (its title, the
+ * kind of source, its host, its authority and when it was fetched).
+ *
+ * The traits come with the bundle. The sources and the verification record
+ * are files of the part (sources.json, verification.json): a host that has
+ * them gives them through the host context (`evidence`), or registers them
+ * (registerEvidenceFiles).
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import { evidenceFor } from "../model/evidence";
+/** Whether a definition has evidence to show (its performance facts count only when `performance` is shown). */
+export declare function hasEvidence(ev: ReturnType<typeof evidenceFor>, performance?: boolean): boolean;
+export declare function EvidenceSection({ def, titled, performance }: {
+    def?: ModuleDef;
+    titled?: boolean;
+    performance?: boolean;
+}): import("react").JSX.Element | null;

package/dist/components/types/uhd-viewer/src/chrome/InterfaceCards.d.ts

@@ -0,0 +1,56 @@
+import type { InterfaceSlot, SlotKind } from "../model/slots";
+/** The card's look, in one place. */
+export declare const CARD_LOOK: {
+    readonly list: "flex flex-col gap-1.5";
+    readonly card: "uhd-slot-card rounded-[6px] border border-line bg-[color-mix(in_oklab,var(--uhd-text)_3%,transparent)] px-2.5 py-[7px] has-[[data-card-toggle]:focus-visible]:outline has-[[data-card-toggle]:focus-visible]:outline-1 has-[[data-card-toggle]:focus-visible]:-outline-offset-1 has-[[data-card-toggle]:focus-visible]:outline-focus hover:border-line-strong";
+    readonly cardOpen: "border-line-strong";
+    readonly cardOpenSlot: "bg-transparent";
+    readonly head: "flex min-w-0 items-center gap-2";
+    /** The toggle covers the whole summary (a stretched button): a click anywhere opens the card. */
+    readonly toggle: "min-w-0 truncate text-left text-[12px] leading-[18px] text-fg outline-none after:absolute after:inset-0 after:content-[''] cursor-pointer";
+    readonly chip: "inline-flex h-[18px] shrink-0 items-center rounded-[4px] bg-[color-mix(in_oklab,var(--uhd-text)_8%,transparent)] px-1.5 text-[10px] leading-none text-fg-muted";
+    readonly pin: "inline-flex h-4 shrink-0 items-center rounded-[4px] border border-line px-1 text-[10px] leading-none text-fg-muted";
+    readonly meta: "mt-[5px] flex min-w-0 items-center gap-1";
+    readonly role: "ml-auto shrink-0 text-[10px] leading-none text-fg-faint";
+    readonly linked: "mt-[5px] flex min-w-0 items-center gap-1.5 text-[11px] leading-[16px]";
+    readonly more: "flex h-6 w-full cursor-pointer items-center gap-1.5 rounded-[3px] px-1 text-left text-[11px] text-fg-muted hover:text-fg focus-visible:outline focus-visible:outline-1 focus-visible:outline-focus";
+    readonly detail: "mt-2 flex flex-col gap-2.5 border-t border-line-subtle pt-2";
+    readonly group: "flex flex-col gap-[3px]";
+    readonly button: "relative z-10 inline-flex h-6 min-w-0 cursor-pointer items-center gap-1.5 rounded-[4px] border border-line px-2 text-[10.5px] leading-none text-fg hover:bg-hover focus-visible:outline focus-visible:outline-1 focus-visible:-outline-offset-1 focus-visible:outline-focus";
+    readonly textAction: "relative z-10 inline-flex shrink-0 cursor-pointer items-center gap-1 text-[10.5px] leading-none text-link hover:underline focus-visible:outline focus-visible:outline-1 focus-visible:outline-focus";
+};
+/** The pin glyph's colour by kind: power red, signal blue, mechanical grey (theme tokens; swap here). */
+export declare const SLOT_COLOR: Record<SlotKind, string>;
+export interface InterfaceCardActions {
+    /** Show the interface (or its first link) on the canvas. */
+    locate?: (slot: InterfaceSlot) => void;
+    /** Select one of its links (or a derived one) by its id on the level. */
+    selectLink?: (id: string) => void;
+    /** Open the source that declares it (its link's line, else the interface's). */
+    openSource?: (slot: InterfaceSlot) => void;
+    /** An open slot: start a link from it. */
+    connect?: (slot: InterfaceSlot) => void;
+    /** A finding's Locate (the host's key), else the slot's own Locate. */
+    finding?: (key: string) => void;
+    /** A source the interface cites. */
+    openLink?: (url: string) => void;
+}
+/** The pin glyph: one bar per pin (up to four), in the kind's colour; an open slot's are outlined. */
+export declare function SlotGlyph({ kind, pins, open }: {
+    kind: SlotKind;
+    pins: number;
+    open?: boolean;
+}): import("react").JSX.Element;
+/** One interface as a slot card; it expands in place. */
+export declare function InterfaceCard({ slot, open, onToggle, actions }: {
+    slot: InterfaceSlot;
+    open: boolean;
+    onToggle: () => void;
+    actions: InterfaceCardActions;
+}): import("react").JSX.Element;
+/** The cards, the first few shown; "N more · names" opens the rest. */
+export declare function InterfaceCards({ slots, actions, first }: {
+    slots: InterfaceSlot[];
+    actions: InterfaceCardActions;
+    first?: number;
+}): import("react").JSX.Element;