@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.1

package/dist/components/types/uhd-viewer/src/theme/tokens.d.ts

@@ -0,0 +1,175 @@
+/**
+ * The viewer's theme-token contract: every colour, surface, shadow and face
+ * the viewer draws with is one of these semantic tokens, read as a CSS
+ * variable (`--uhd-<kebab-name>`). Nothing in the viewer's styles names a raw
+ * colour; a host restyles the viewer by giving these tokens values (a theme),
+ * never by overriding class rules.
+ *
+ * A theme is plain data (`Theme`). Values may be any CSS value, including
+ * `var(...)` references to the host's own variables (the VS Code adapter maps
+ * every token onto `--vscode-*`) and `color-mix(...)` of other tokens.
+ *
+ * Nothing here names a host product: hosts bring their own themes through
+ * `defineTheme` (or a `ThemeAdapter`, ./adapters.ts).
+ */
+/** Every token, grouped as the contract documents them. */
+export interface ThemeTokens {
+    /** The page behind everything (the app shell). */
+    background: string;
+    /** The diagram canvas. */
+    canvas: string;
+    /** The canvas's dot grid. */
+    canvasDot: string;
+    /** Panels and floating cards (inspector, legend, toolbars). */
+    surface: string;
+    /** Popovers, menus and tooltips above a surface. */
+    surfaceRaised: string;
+    /** Wells inside a surface: inputs, code, table bands, drawing frames. */
+    surfaceSunken: string;
+    /** Floating chrome laid over the canvas (translucent surface). */
+    overlay: string;
+    /** Behind a modal view (dims the canvas). */
+    scrim: string;
+    /** Muted fill (chips, progress tracks). */
+    muted: string;
+    /** Hover fill on a control or row. */
+    hover: string;
+    /** Pressed / active fill on a control. */
+    active: string;
+    /** A module card on the canvas. */
+    node: string;
+    /** A selected module card. */
+    nodeSelected: string;
+    /** A group container's fill. */
+    group: string;
+    /** Behind artifact image previews (most part drawings are made for paper). */
+    preview: string;
+    /** Behind board drawings (PCB layers). */
+    drawing: string;
+    text: string;
+    textMuted: string;
+    textFaint: string;
+    /** Text on an accent fill. */
+    textOnAccent: string;
+    /** A link-like text button. */
+    textLink: string;
+    border: string;
+    borderSubtle: string;
+    borderStrong: string;
+    /** A module card's outline. */
+    nodeBorder: string;
+    /** A module card's outline under the pointer. */
+    nodeBorderHover: string;
+    /** A group container's dashed outline. */
+    groupBorder: string;
+    /** Extra outline drawn around every control in a high-contrast theme (transparent otherwise). */
+    contrastBorder: string;
+    /** Outline of the active / selected control in a high-contrast theme (transparent otherwise). */
+    contrastActiveBorder: string;
+    /** The one accent: selection, active toggles, the focused link. */
+    accent: string;
+    accentHover: string;
+    /** A light wash of the accent (an active tab, a selected row). */
+    accentTint: string;
+    /** The accent's glow around a selected card. */
+    accentGlow: string;
+    /** A second highlight, distinct from the accent (a counterpart, an interface). */
+    highlight: string;
+    /** Keyboard focus outline. */
+    focusRing: string;
+    /** A selected row's or item's fill. */
+    selection: string;
+    /** Text on a selected row. */
+    selectionText: string;
+    domainElectrical: string;
+    domainMechanical: string;
+    domainPneumatic: string;
+    domainHydraulic: string;
+    domainThermal: string;
+    domainNetwork: string;
+    domainSoftware: string;
+    /** Items outside the classification's focus (signal mode's other domains). */
+    domainOther: string;
+    signalPower: string;
+    signalGround: string;
+    signalDigital: string;
+    signalAnalog: string;
+    signalI2c: string;
+    signalSpi: string;
+    signalUart: string;
+    signalCan: string;
+    signalPwm: string;
+    signalPhase: string;
+    signalRf: string;
+    signalOther: string;
+    drcConfigured: string;
+    drcPartial: string;
+    drcIncompatible: string;
+    drcUnconfigured: string;
+    severityError: string;
+    severityWarning: string;
+    severityInfo: string;
+    severityOk: string;
+    scrollbarThumb: string;
+    scrollbarThumbHover: string;
+    sceneBackground: string;
+    sceneGrid: string;
+    sceneGridMinor: string;
+    radius: string;
+    shadowSm: string;
+    shadowMd: string;
+    shadowLg: string;
+    /** Interface text (labels, buttons, values). */
+    fontUi: string;
+    /** Display face for headings and card titles. */
+    fontLabel: string;
+    /** Code, ids and numbers. */
+    fontMono: string;
+}
+export type ThemeToken = keyof ThemeTokens;
+/** Light or dark surfaces, and whether the host asks for high contrast. */
+export type ThemeScheme = "dark" | "light" | "high-contrast" | "high-contrast-light";
+export interface Theme {
+    /** A stable id (`default-dark`, `vscode`, a host's own). */
+    id: string;
+    /** For people choosing a theme. */
+    label: string;
+    scheme: ThemeScheme;
+    tokens: ThemeTokens;
+}
+/** The CSS variable of a token: `textMuted` → `--uhd-text-muted`. */
+export declare const tokenVar: (token: ThemeToken) => string;
+/** `var(--uhd-…)` for a token, to use in inline styles and SVG attributes. */
+export declare const token: (name: ThemeToken) => string;
+/** Every token name, in contract order (used by tests, adapters and docs). */
+export declare const TOKEN_NAMES: readonly ThemeToken[];
+/** A wash of another token: `mix("accent", 15)` is the accent at 15 % over transparent. */
+export declare const mix: (name: ThemeToken, percent: number, over?: string) => string;
+/**
+ * Tokens that follow from others unless a theme sets them: the accent's tint
+ * and glow, hover and active washes of the text colour, the selection. A
+ * theme that sets only the accent still gets a coherent set.
+ */
+export declare const DERIVED: Partial<ThemeTokens>;
+/**
+ * A complete theme from a base and the tokens that change. Derived tokens
+ * (DERIVED) are recomputed from the result unless `tokens` sets them.
+ */
+export declare function defineTheme(base: Theme, change: {
+    id: string;
+    label: string;
+    scheme?: ThemeScheme;
+    tokens?: Partial<ThemeTokens>;
+}): Theme;
+/** The CSS declarations of a theme (`--uhd-x: value;` …), for a stylesheet or an inline style. */
+export declare function themeDeclarations(theme: Theme): string;
+/** A stylesheet rule applying a theme under `selector`. */
+export declare const themeCss: (theme: Theme, selector?: string) => string;
+/**
+ * Applies a theme to an element: every token as an inline CSS variable, and
+ * `data-uhd-theme` / `data-uhd-scheme` for rules that differ by scheme (high
+ * contrast draws thicker outlines). Returns a function that removes it.
+ */
+export declare function applyTheme(element: HTMLElement, theme: Theme): () => void;
+/** A token's resolved value on an element (for canvases that cannot read CSS: the 3D scene). */
+export declare function readToken(element: Element, name: ThemeToken): string;

package/dist/components/types/uhd-viewer/src/ui/Inspector.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Base inspector primitives: a panel with a header and a scrolling body,
+ * titled sections, key/value rows, badges and status dots. Shells build their
+ * inspectors (and hosts their native-looking side views) from these.
+ */
+import type { ReactNode } from "react";
+export interface InspectorPanelProps {
+    /** The header's title ("Inspector", a module's name). */
+    title?: ReactNode;
+    /** Icon buttons or tabs at the header's right. */
+    actions?: ReactNode;
+    children?: ReactNode;
+    className?: string;
+    /** Classes of the scrolled content. */
+    bodyClassName?: string;
+}
+/** A panel: header, then a body that scrolls with the themed scrollbar. */
+export declare function InspectorPanel({ title, actions, children, className, bodyClassName }: InspectorPanelProps): import("react").JSX.Element;
+export declare function Section({ title, count, actions, children }: {
+    title: ReactNode;
+    count?: number;
+    actions?: ReactNode;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+/** A key and its value on one line (nothing when the value is empty). */
+export declare function PropertyRow({ name, value, mono }: {
+    name: ReactNode;
+    value?: ReactNode;
+    mono?: boolean;
+}): import("react").JSX.Element | null;
+export type Tone = "neutral" | "accent" | "ok" | "warning" | "error" | "info";
+export declare function Badge({ tone, children }: {
+    tone?: Tone;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function StatusDot({ tone, label }: {
+    tone?: Tone;
+    label?: string;
+}): import("react").JSX.Element;
+/** A quiet message where a panel has nothing to show yet. */
+export declare function EmptyState({ icon, title, children }: {
+    icon?: ReactNode;
+    title: ReactNode;
+    children?: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/ui/Legend.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Legend primitives: a floating card with a title and swatches. A swatch is
+ * a short line (links) or a dot (states). An item given `onSelect` is a
+ * button: the legend then isolates what it stands for. An item with a
+ * `meaning` reads as two lines, its name and what it stands for. A compact
+ * item is its swatch alone, named by its label (`LegendSwatches` lays them
+ * out). Folded, a legend is a tab at the right edge (`LegendTab`): a chevron
+ * and a dot per colour.
+ */
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode, Ref } from "react";
+export interface LegendProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    title?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /** As narrow as its content (a compact legend of swatches); else at least 150 px. */
+    compact?: boolean;
+}
+export declare function Legend({ title, children, className, compact, ...rest }: LegendProps): import("react").JSX.Element;
+export interface LegendItemProps {
+    color: string;
+    label: ReactNode;
+    shape?: "line" | "dot" | "dash";
+    /** Given: the item is a button. `add` says a modifier key was held (add to, or take from, the ones held). */
+    onSelect?: (add: boolean) => void;
+    /** The item is the one (or one of those) isolated. */
+    pressed?: boolean;
+    /** Another item is isolated: this one steps back. */
+    dimmed?: boolean;
+    /** Nothing here is of this kind: the button is disabled and says so. */
+    absent?: boolean;
+    /** The button's tooltip. */
+    hint?: string;
+    /** A second line of the tooltip (how to hold several). */
+    hintShortcut?: string;
+    /** The swatch alone (a narrow legend): the label names the button and is its tooltip. */
+    compact?: boolean;
+    /** What the entry stands for, in a few words: a second, muted line under the label. */
+    meaning?: string;
+}
+export declare function LegendItem({ color, label, shape, onSelect, pressed, dimmed, absent, hint, hintShortcut, compact, meaning }: LegendItemProps): import("react").JSX.Element;
+/** Compact items side by side, `columns` to a row: a legend as narrow as its swatches. */
+export declare function LegendSwatches({ columns, children, label }: {
+    columns?: number;
+    children?: ReactNode;
+    label?: string;
+}): import("react").JSX.Element;
+export interface LegendTabProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /** A dot per colour the legend explains (`dimmed`: it steps back, as an entry does while another is isolated). */
+    dots: {
+        key: string;
+        color: string;
+        dimmed?: boolean;
+    }[];
+    ref?: Ref<HTMLButtonElement>;
+}
+/**
+ * A folded legend: a narrow tab at the right edge, a chevron and the
+ * colours it explains as dots. A click opens the legend; its label names it.
+ */
+export declare function LegendTab({ dots, className, ...rest }: LegendTabProps): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/ui/ScrollArea.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+export interface ScrollAreaProps {
+    children?: ReactNode;
+    /**
+     * Classes of the root. It is a flex column, so a height (a flex child with
+     * min-h-0) or a max height (`max-h-64`) is all the scrolled viewport needs.
+     */
+    className?: string;
+    /** Classes of the scrolled viewport's content wrapper. */
+    contentClassName?: string;
+    /** Which bars to offer (default vertical). */
+    axis?: "vertical" | "horizontal" | "both";
+    /** `hover` shows the bars while the pointer is over the area; `scroll` only while scrolling (default hover). */
+    type?: "hover" | "scroll" | "auto" | "always";
+}
+export declare const ScrollArea: import("react").ForwardRefExoticComponent<ScrollAreaProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/types/uhd-viewer/src/ui/Toolbar.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Toolbar primitives: a floating card of icon buttons, each naming itself in
+ * a tooltip (no text toolbars). Toggles show their state with an accent wash,
+ * an accent outline and `aria-pressed`; a high-contrast theme outlines them
+ * instead.
+ */
+import { type ButtonHTMLAttributes, type ReactNode } from "react";
+export interface ToolbarProps {
+    children?: ReactNode;
+    className?: string;
+    orientation?: "horizontal" | "vertical";
+    /** For assistive technology ("Diagram tools"). */
+    label?: string;
+}
+/** A floating card holding icon buttons and separators. */
+export declare function Toolbar({ children, className, orientation, label }: ToolbarProps): import("react").JSX.Element;
+export declare function ToolbarSeparator({ orientation }: {
+    orientation?: "vertical" | "horizontal";
+}): import("react").JSX.Element;
+export interface IconButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    /** A Lucide icon name (kebab-case), or the icon itself. */
+    icon: string | ReactNode;
+    /** What the button does: its tooltip and accessible name. */
+    label: string;
+    /** A toggle's state (absent: a plain action). */
+    pressed?: boolean;
+    shortcut?: string;
+    tooltipSide?: "top" | "bottom" | "left" | "right";
+    size?: "sm" | "md";
+    /** A count or dot over the icon (errors on a checks button). */
+    badge?: ReactNode;
+}
+export declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface ToggleGroupProps<T extends string> {
+    /** The choices, each an icon with a label for its tooltip. */
+    options: readonly {
+        id: T;
+        icon: string | ReactNode;
+        label: string;
+        disabled?: boolean;
+    }[];
+    value: T;
+    onChange: (value: T) => void;
+    label?: string;
+    tooltipSide?: IconButtonProps["tooltipSide"];
+    size?: IconButtonProps["size"];
+}
+/** One of several, as icon buttons side by side. */
+export declare function ToggleGroup<T extends string>({ options, value, onChange, label, tooltipSide, size }: ToggleGroupProps<T>): import("react").JSX.Element;

package/dist/components/types/uhd-viewer/src/ui/Tooltips.d.ts

@@ -0,0 +1,3 @@
+export declare function Tooltips({ root }: {
+    root: HTMLElement | null;
+}): import("react").JSX.Element | null;

package/dist/components/types/uhd-viewer/src/ui/cx.d.ts

@@ -0,0 +1,2 @@
+/** Class names joined, falsy ones dropped. */
+export declare const cx: (...names: (string | false | null | undefined)[]) => string;

package/dist/components/types/uhd-viewer/src/ui/legendFit.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How much of the diagram's legend fits beside the bottom toolbar. The legend
+ * stays where it is (bottom right) and gives way as the toolbar comes near:
+ * the full card, then a compact one (swatches without their labels), then,
+ * at its smallest, a button in the toolbar that opens it. Folded, it is a
+ * narrow tab at the right edge, which gives way to the button the same way.
+ * A short canvas folds it (`legendShort`). No DOM here: the legend measures,
+ * this decides.
+ */
+export type LegendStage = "full" | "compact" | "button";
+/** Space kept between the legend and the toolbar (px). */
+export declare const LEGEND_GAP = 8;
+/** A larger form comes back only with this much room to spare (px), so a width at the edge does not flicker between two. */
+export declare const LEGEND_HYSTERESIS = 6;
+/** Below this canvas height (px) the legend folds by itself: open, it would cover much of the drawing. */
+export declare const LEGEND_SHORT = 500;
+export interface Box {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface LegendMeasure {
+    /** Where the legend's right edge is (the same for every form). */
+    right: number;
+    /** Each form's box, as it would sit (bottom right). */
+    full: Box;
+    compact: Box;
+    /** The folded tab's box, as it would sit (at the right edge). */
+    tab?: Box;
+    /** The toolbar's box, or none (no toolbar, or hidden). */
+    toolbar?: Box | null;
+    /** The legend's button in the toolbar takes this much of it (its width and gap), when it is there: the toolbar is measured as if it were not. */
+    slot?: number;
+}
+/**
+ * The room the legend has before the toolbar (px): from the toolbar's right
+ * edge to the legend's, less the gap. The toolbar is centred, so its button
+ * for the legend moves its right edge by half the button: that half is taken
+ * back, and the room is the same whether or not the button is in it.
+ */
+export declare function legendRoom(m: Pick<LegendMeasure, "right" | "toolbar" | "slot">): number;
+/**
+ * The largest form that does not run into the toolbar. A form fits when it is
+ * clear of the toolbar's height, or narrower than the room. Moving up to a
+ * larger form than `current` takes `LEGEND_HYSTERESIS` more. Folded
+ * (`folded`), the tab is the only form: "full" while it fits, else "button".
+ */
+export declare function legendStage(m: LegendMeasure, current?: LegendStage, folded?: boolean): LegendStage;
+/**
+ * Whether the legend shows folded: the user folded it, or the canvas is
+ * shorter than `LEGEND_SHORT` and the user has not opened it since it became
+ * so (`peek`).
+ */
+export declare function legendFolded(open: boolean, canvasHeight: number, peek: boolean): boolean;

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

@@ -0,0 +1,219 @@
+import { Component, type ErrorInfo, type ReactNode } from "react";
+import type { ChildLink } from "@deltarobotics/uhd";
+import type { UhdBundleDiagnostic } from "@deltarobotics/uhd";
+import type { Classification } from "../model/classification";
+import type { ViewLink } from "../model/types";
+import { type ComputedLayout, type LevelLayout, type LinkLayout } from "../layout/layout";
+import type { Pt } from "../canvas/routing";
+import { type LoadedSource } from "../source/source";
+import type { ViewerEvent, ViewerOptions, ViewerSelection } from "../api";
+import type { Selection, ViewCommand } from "../canvas/Canvas";
+import { type CanvasTool, type Viewport } from "../canvas/interaction";
+import type { Goto, NodeMenuItem, Panel } from "../chrome/Chrome";
+import type { CadSelection } from "../cad/CadView";
+import type { LegendStage } from "../ui/legendFit";
+import type { CommandBus } from "../host/channel";
+import { type HostActions } from "../host/context";
+type Overrides = Record<string, ChildLink[]>;
+/** What is being dragged right now (see LiveLayout). */
+export interface Live {
+    nodes?: Set<string>;
+    links?: Set<string>;
+}
+export interface AppProps extends ViewerOptions {
+    /** Development only: absolute artifact bases are served through Vite's /@fs route. */
+    fsRoute?: boolean;
+    /** The host channel (mount.tsx): its messages, where events go, and which open actions the host takes. */
+    host?: HostLink;
+}
+export interface HostLink {
+    bus: CommandBus;
+    emit: (event: ViewerEvent) => void;
+    /** The host opens sources (the viewer offers OPEN SOURCE). */
+    source: boolean;
+    /** The host opens artifact files (instead of a new tab). */
+    artifact: boolean;
+    /** The host opens modules on their own (double-click), `onOpenModule`. */
+    module?: boolean;
+    /** The host shows the pair view (instead of the viewer's own over the diagram). */
+    pair?: boolean;
+    /** The host has an inspector of its own and shows a module there when asked (`onInspect`). */
+    inspect?: boolean;
+}
+/** Loads the UHD bundle (the viewer's only input): the source once loaded, or why not. */
+export declare function useViewerSource(props: Pick<AppProps, "bundle" | "bundleUrl" | "resolveArtifact" | "fsRoute">): {
+    source: LoadedSource | null;
+    error: string | null;
+    empty: boolean;
+};
+/**
+ * The viewer's state and behaviour for one loaded bundle: what is drawn, what
+ * is selected, the drill level, the classification, layout edits, the host
+ * channel. Shells read it through `useViewer()` inside `UhdViewer`; the
+ * canvases, inspector panels, toolbar and legend are views of it.
+ */
+export declare function useViewerController(source: LoadedSource, options: ViewerOptions, host?: HostLink): {
+    source: LoadedSource;
+    options: ViewerOptions;
+    scenario: import("../source/source").ViewerScenario;
+    scenarios: {
+        id: string;
+        label: string;
+    }[];
+    onScenario: (id: string) => void;
+    system: import("@deltarobotics/uhd").ModuleDef;
+    vm: import("../components").ViewModel;
+    drawn: import("../components").ViewModel;
+    layout: ComputedLayout;
+    hand: LevelLayout;
+    levelKey: string;
+    levelDef: import("@deltarobotics/uhd").ModuleDef;
+    drill: string[];
+    topLevel: boolean;
+    diagnostics: import("../model/diagnostics").ScopedDiagnostic[];
+    hostDiagnostics: UhdBundleDiagnostic[];
+    errors: number;
+    defFor: (id?: string) => import("@deltarobotics/uhd").ModuleDef | undefined;
+    bSlotsFor: (link: ViewLink) => string[];
+    view: "3d" | "diagram";
+    setView: import("react").Dispatch<import("react").SetStateAction<"3d" | "diagram">>;
+    mode: Classification;
+    setMode: (m: Classification) => void;
+    conductors: boolean;
+    setConductors: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    showGrounds: boolean;
+    setShowGrounds: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    isolated: ReadonlySet<string>;
+    isolation: import("../components").Isolation | null;
+    present: Set<string>;
+    onIsolate: (key: string, add?: boolean) => void;
+    clearIsolated: () => void;
+    legendStage: LegendStage;
+    setLegendStage: import("react").Dispatch<import("react").SetStateAction<LegendStage>>;
+    panel: Panel | null;
+    setPanel: import("react").Dispatch<import("react").SetStateAction<Panel | null>>;
+    selection: Selection;
+    setSelection: (s: Selection) => void;
+    group: readonly string[];
+    onSelectChanges: (changes: readonly {
+        id: string;
+        selected: boolean;
+    }[]) => void;
+    onSelectAll: () => void;
+    onEscape: () => void;
+    interaction: import("../components").InteractionState;
+    onInteraction: import("react").ActionDispatch<[action: import("../components").InteractionAction]>;
+    tool: CanvasTool;
+    setTool: (tool: CanvasTool) => void;
+    viewCommand: ViewCommand | undefined;
+    fitView: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    viewport: Viewport | undefined;
+    /** Counts the times a host replaced the viewports: the canvas opens again on them. */
+    viewportsSeq: number;
+    onViewport: (v: Viewport | null) => void;
+    openLinks: Set<string>;
+    overrides: Overrides;
+    pair: ViewLink | undefined;
+    setPairLink: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    onNavigate: (depth: number) => void;
+    onDrill: (id: string) => void;
+    onGoto: (g: Goto) => void;
+    onPair: (l: ViewLink) => void;
+    onReset: () => void;
+    onToggleLink: (id: string) => void;
+    onToggleExpand: (id: string) => void;
+    onMove: (id: string, x: number, y: number) => void;
+    onOverride: (linkId: string, childLinks: ChildLink[] | null) => void;
+    editLink: (linkId: string, patch: LinkLayout) => void;
+    onPins: (linkId: string, pins: Pt[]) => void;
+    setLive: import("react").Dispatch<import("react").SetStateAction<Live | null>>;
+    centre: {
+        id: string;
+        seq: number;
+        lines?: readonly string[];
+    } | undefined;
+    reveal: {
+        selection: NonNullable<Selection>;
+        seq: number;
+    } | undefined;
+    cadFocus: {
+        path: string;
+        seq: number;
+        kind?: "node" | "link" | "none";
+        look?: boolean;
+    } | undefined;
+    onCadSelect: (s: CadSelection) => void;
+    cadSelection: ViewerSelection | null;
+    focusPath: (path: string) => void;
+    hostActions: HostActions;
+    onOpenNode: (id: string) => void;
+    onNodeContext: (id: string, x: number, y: number) => void;
+    onPaneContext: (x: number, y: number) => void;
+    menu: {
+        id?: string;
+        x: number;
+        y: number;
+    } | null;
+    menuItems: NodeMenuItem[];
+    closeMenu: () => void;
+};
+/**
+ * What a double-click on a node does: `open` it on its own (the host's new
+ * tab), `expand` it in place, or `none`. Only a module that holds modules
+ * has a level to open or to expand; a part with nothing inside, a net's
+ * junction, a rail's tap and a boundary port have none.
+ */
+export declare function openAction(node: {
+    defId?: string;
+    childCount?: number;
+    net?: unknown;
+    tapOf?: string;
+    sheetPort?: unknown;
+} | undefined, hostOpens: boolean): "open" | "expand" | "none";
+/** Everything a view of the loaded model reads (see useViewerController). */
+export type ViewerController = ReturnType<typeof useViewerController>;
+/** The viewer's state, inside `UhdViewer` (or `ViewerProvider`). */
+export declare function useViewer(): ViewerController;
+/** The viewer's state for a loaded source, for the components inside. */
+export declare function ViewerProvider({ source, options, host, children }: {
+    source: LoadedSource;
+    options: ViewerOptions;
+    host?: HostLink;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export interface UhdViewerProps extends AppProps {
+    /** The views of the model: canvases, panels, the shell's own chrome. */
+    children?: ReactNode;
+}
+/**
+ * Loads the bundle, then provides the viewer's state to `children`. While
+ * loading, or when the bundle cannot be read, it says so in place.
+ */
+export declare function UhdViewer({ children, ...props }: UhdViewerProps): import("react").JSX.Element;
+/**
+ * A bundle the viewer cannot draw says so in place, instead of leaving an
+ * empty page: what failed, and that the next bundle is tried again (a
+ * producer that rebuilds on a source edit sends one).
+ */
+export declare class ViewerBoundary extends Component<{
+    source: LoadedSource;
+    children?: ReactNode;
+}, {
+    failed?: {
+        source: LoadedSource;
+        message: string;
+    };
+}> {
+    state: {
+        failed?: {
+            source: LoadedSource;
+            message: string;
+        };
+    };
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    static getDerivedStateFromError(): null;
+    render(): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
+}
+export {};