@deltarobotics/uhd-viewer 0.0.0-stage → 0.2.0

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,182 @@
+/**
+ * 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;
+    /** 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>;
+};

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

@@ -0,0 +1,213 @@
+/**
+ * Neutral view contract (PB-784). The canvas renders only these types; the
+ * UHD adapter (./from-uhd.ts) produces them from a system ModuleDef.
+ * Every id is a canonical path so layout and selection survive model edits.
+ */
+export type LinkState = "configured" | "partial" | "incompatible" | "unconfigured";
+export type NodeKind = "module" | "group" | "harness" | "board" | "net";
+export type Shape = "rect" | "circle" | "pill";
+/** A child interface revealed when a link is opened (a slot and the leaf bound to it). */
+export interface ViewChildPort {
+    slotId: string;
+    name: string;
+    /** Leaf interface id on the module, e.g. "gnss_uart_tx". */
+    leafId?: string;
+    /** Pad or pin label, e.g. "TX". */
+    pin?: string;
+}
+export interface ViewPort {
+    /** Interface id on its module (or export id on a group/module boundary). */
+    id: string;
+    name: string;
+    domain: string;
+    /** Primary protocol type, used for signal-type classification and grouping. */
+    protocol: string;
+    roles: string[];
+    children: ViewChildPort[];
+    /** True when the port is a boundary export of a child interface. */
+    exported?: {
+        child: string;
+        interfaceId: string;
+    };
+}
+export interface ViewNode {
+    /** Canonical path, e.g. "stack/esc" or "arm_fl". */
+    id: string;
+    label: string;
+    icon: string;
+    kind: NodeKind;
+    /** Parent node path when drawn inside an expanded module or group. */
+    parent?: string;
+    /** True when the node has children and is drawn expanded in place. */
+    expanded?: boolean;
+    ports: ViewPort[];
+    shape: Shape;
+    status: LinkState;
+    /** UHD definition id, for the inspector. */
+    defId?: string;
+    manufacturer?: string;
+    partNumber?: string;
+    description?: string;
+    category?: string;
+    childCount: number;
+    /** A boundary port of the drilled-into module, drawn at the canvas edge. */
+    sheetPort?: boolean;
+    /** A board net (PB-823): drawn as a junction its members' grouped membership links meet at. */
+    net?: ViewNet;
+    /**
+     * A rail drawn in several places (PB-873): this junction is a local tap of the
+     * net junction with this id, joined to the members near it. Selecting a tap
+     * selects the net.
+     */
+    tapOf?: string;
+    /** The bundle does not hold this module's definition: a placeholder with the interfaces its links name. */
+    missing?: boolean;
+}
+/** A net on a board (UHD `Net` interface, exposed: false), as a junction node. */
+export interface ViewNet {
+    /** Net interface id on the board, e.g. "v3v3". */
+    id: string;
+    name: string;
+    /** What the net carries, for the signal classification: "power", "ground", "i2c", "digital"… */
+    signal: string;
+    /** Design voltage as stated on the net ("3.3 V", "2.5–5.5 V"). */
+    voltage?: string;
+    /** A ground net: drawn as ground symbols at its members unless GND wires are on. */
+    ground: boolean;
+    /** Pins on the net. */
+    pins: number;
+}
+export interface ViewEndpoint {
+    node: string;
+    port: string;
+}
+export interface ViewChildLink {
+    id: string;
+    label: string;
+    a: string;
+    b: string;
+    aPin?: string;
+    bPin?: string;
+    state: LinkState;
+}
+/**
+ * One lane of an expanded link (PB-803/805): a child interface of the link,
+ * or a link derived through a cable. A lane with its own children is itself a
+ * bundle and can be opened in place.
+ */
+export interface ViewLane {
+    id: string;
+    name: string;
+    domain: string;
+    protocol: string;
+    state: LinkState;
+    children: ViewLane[];
+    /** Conductor ids this lane carries (ribbon mode groups them under the lane). */
+    conductors?: string[];
+}
+/** One physical conductor of a link, for ribbon (detailed) mode. */
+export interface ViewConductor {
+    id: string;
+    label: string;
+    /** Signal protocol of the conductor, for its colour ("power", "ground", "uart", …). */
+    protocol: string;
+    domain: string;
+    /** DRC state of the connection this conductor carries. */
+    state: LinkState;
+}
+/** The harness a link runs through, drawn as a region along its route. */
+export interface ViewHarnessRun {
+    /** Harness child path at this level. */
+    id: string;
+    /** Its UHD definition id (for the inspector: artifacts, thumbnail, CAD). */
+    defId: string;
+    name: string;
+    icon: string;
+    /** Carried by a physical cable (connector ends) rather than named on a logical link. */
+    physical: boolean;
+    /** Only the first link of a harness carries its name tab. */
+    tab: boolean;
+}
+export interface ViewLink {
+    id: string;
+    source: ViewEndpoint;
+    target: ViewEndpoint;
+    name: string;
+    domain: string;
+    protocol: string;
+    state: LinkState;
+    children: ViewChildLink[];
+    /** Pass-through from a boundary export to the child interface it exposes. */
+    passThrough?: boolean;
+    /** Ground return: drawn as ground symbols at both ports instead of a wire. */
+    ground?: boolean;
+    /** Harness node carrying the link, if any. */
+    harness?: string;
+    /**
+     * A link carried by a harness is drawn as two segments through the harness
+     * node: "a" (source → harness, carries the label) and "b" (harness → target).
+     */
+    segment?: "a" | "b";
+    /** Stored link id (shared by both segments). */
+    linkId: string;
+    /** Other stored link ids drawn by this link (the second half of a cable). */
+    alsoIds?: string[];
+    /** Lanes shown when the link is expanded (basic mode). */
+    lanes?: ViewLane[];
+    /** Conductors shown in ribbon (detailed) mode. */
+    conductors?: ViewConductor[];
+    /** Harness region along the route. */
+    run?: ViewHarnessRun;
+    /** Child links are a stored override (remapped by the user). */
+    manual?: boolean;
+    /** Grouped net membership (PB-823): one line from a component to a net, its pins as children. */
+    net?: {
+        id: string;
+        name: string;
+    };
+    diagnostics: string[];
+}
+/**
+ * A functional link UHD derives over a board's nets (an I2C bus, a supply to
+ * a load). It is not drawn as a line of its own: the membership lines it runs
+ * over (`via`) carry its state, and the inspector lists it by name.
+ */
+export interface ViewDerived {
+    /** Derived link id (long: the membership links it runs over), prefixed like stored link ids. */
+    id: string;
+    /** Its name, "I2C0 ↔ I2C": what the viewer shows instead of the id. */
+    name: string;
+    protocol: string;
+    state: LinkState;
+    a: {
+        node: string;
+        iface: string;
+    };
+    b: {
+        node: string;
+        iface: string;
+    };
+    /** Net node ids it runs over. */
+    nets: string[];
+    /** View link ids (grouped memberships) it runs over. */
+    via: string[];
+    /** Conductors: each slot (or pin) and the one it is wired to. */
+    children: {
+        a: string;
+        aPin?: string;
+        b: string;
+        bPin?: string;
+    }[];
+    diagnostics: string[];
+}
+export interface ViewModel {
+    /** Breadcrumb labels for the level being viewed. */
+    path: {
+        id: string;
+        label: string;
+    }[];
+    nodes: ViewNode[];
+    links: ViewLink[];
+    /** Functional links derived over the level's nets (and nets of modules expanded in place). */
+    derived: ViewDerived[];
+}

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

@@ -0,0 +1,27 @@
+/**
+ * How a host's option changes apply (ViewerHandle.update). Kept apart from
+ * mount.tsx so it can be tested without a page.
+ */
+import type { ViewerLayout, ViewerOptions, ViewerViewport } from "./api";
+/**
+ * The options after `update(change)`: the change is merged into the current
+ * options. A change that names `bundleUrl` and not `bundle` switches to
+ * loading from that URL (a given `bundle` would otherwise keep precedence).
+ */
+export declare function mergeOptions<T extends ViewerOptions>(current: T, change: Partial<ViewerOptions>): T;
+/** The same layout edits (a host passing back what the viewer sent is not a change). */
+export declare function sameLayout(a: ViewerLayout | undefined, b: ViewerLayout | undefined): boolean;
+/** The same saved viewports, whatever order their levels come in (a host passing back what the viewer sent is not a change). */
+export declare function sameViewports(a: Record<string, ViewerViewport> | undefined, b: Record<string, ViewerViewport> | undefined): boolean;
+/**
+ * What a host's `viewports` option asks of a mounted viewer (PB-1037):
+ * `replace` when the viewer must take them (the host passed viewports it was
+ * not sent, or it took over keeping them, or gave that up), `keep` otherwise.
+ * `known` is what the host has: what it passed last or what it was last sent.
+ */
+export declare function hostViewportsChange(o: {
+    hosted: boolean;
+    wasHosted: boolean;
+    host: Record<string, ViewerViewport> | undefined;
+    known: Record<string, ViewerViewport> | undefined;
+}): "replace" | "keep";

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

@@ -0,0 +1,109 @@
+import { type UhdBundle, type UhdBundleDiagnostic } from "@deltarobotics/uhd";
+import type { ModuleDef } from "@deltarobotics/uhd";
+import type { ModuleLookup } from "@deltarobotics/uhd";
+import type { LevelLayout } from "../layout/layout";
+import type { ArtifactResolver, ViewerOptions } from "../api";
+import { type LeftOut, type MissingDefinition } from "./tolerant";
+export interface ViewerScenario {
+    id: string;
+    label: string;
+    description: string;
+    system: ModuleDef;
+    lookup: ModuleLookup;
+    /** Definitions the bundle names and does not hold: drawn as placeholders (source/tolerant.ts). */
+    missing: MissingDefinition[];
+    /** Links and exports that could not be resolved, and are not drawn. */
+    leftOut: LeftOut[];
+}
+/** Surface appearance for a definition (and optionally named sub-bodies of its CAD). */
+export interface Appearance {
+    color?: string;
+    metalness?: number;
+    roughness?: number;
+    opacity?: number;
+    parts?: Record<string, Omit<Appearance, "parts">>;
+}
+export interface LabelHint {
+    title?: string;
+    sub?: string;
+    hide?: boolean;
+}
+/** Presentation hints keyed by instance path. Never topology. */
+export interface DisplayConfig {
+    diagram?: {
+        /** Hand layouts per drill level ("" = top). */
+        layouts?: Record<string, LevelLayout>;
+        /** Instance paths drawn expanded in place by default. */
+        expanded?: string[];
+        /** Links opened (conductors shown) by default. */
+        openLinks?: string[];
+    };
+    spatial?: {
+        /** Instance path the assembly is placed from (default: the best-connected structure). */
+        root?: string;
+        /** Explicit placements for modules no mate reaches (row-major 4×4, root coordinates). */
+        placements?: Record<string, {
+            matrix: number[];
+            note?: string;
+        }>;
+        labels?: {
+            modules?: Record<string, LabelHint>;
+            /** Fastener harnesses and routed wire harnesses, by instance path. */
+            harnesses?: Record<string, LabelHint>;
+        };
+        /** By definition id. */
+        appearance?: Record<string, Appearance>;
+        /** How the 3D view opens (PB-873). */
+        view?: SpatialView;
+    };
+}
+/**
+ * The 3D view's opening camera, in the root's coordinates. Presentation only:
+ * a watch modelled display-down (its case's frame has the display at −z)
+ * says `up: [0, 0, -1]` and opens display-up, without changing the model.
+ */
+export interface SpatialView {
+    /** The direction drawn up (default [0, 0, 1]): the camera's up, the orbit axis and the ground grid follow it. */
+    up?: [number, number, number];
+    /** A saved camera: azimuth and elevation (degrees, about `up`), distance (mm) and target. Without a distance the model is fitted. */
+    camera?: {
+        azimuth?: number;
+        elevation?: number;
+        distance?: number;
+        target?: [number, number, number];
+    };
+}
+export interface LoadedSource {
+    name: string;
+    bundleUrl: string;
+    scenarios: ViewerScenario[];
+    /** URL for a definition's artifact file path, or undefined if it cannot be resolved. */
+    resolveArtifact: ArtifactResolver;
+    /** Findings from the bundle's producer (e.g. Protoboard's aggregated check). */
+    hostDiagnostics: UhdBundleDiagnostic[];
+    display: DisplayConfig;
+    /** The bundle as loaded (for host views that read more of it than the viewer draws). */
+    bundle: UhdBundle;
+}
+export interface SourceOptions {
+    /** Development only: absolute filesystem bases are served through Vite's /@fs route. */
+    fsRoute?: boolean;
+    /** A host's resolver; it receives the default one as `fallback`. */
+    resolveArtifact?: ViewerOptions["resolveArtifact"];
+}
+/**
+ * The bundle URL for the standalone app: `?bundle=<url>`, then the URL a
+ * server injected into the page, then the development default (none in a
+ * production build).
+ */
+export declare function pickBundleUrl(search: string, injected?: string | null, fallback?: string | null): string | undefined;
+/**
+ * URL prefix for an artifact base (`UhdBundle.artifactBases`: an absolute
+ * path or a URL prefix), or undefined when it cannot be fetched over HTTP.
+ * Absolute filesystem paths only resolve in development, through /@fs.
+ */
+export declare function baseToUrl(base: string, options?: Pick<SourceOptions, "fsRoute">): string | undefined;
+/** The default resolver: a definition's artifact base, or the bundle's own location. */
+export declare function bundleResolver(bundle: UhdBundle, bundleUrl: string, options?: Pick<SourceOptions, "fsRoute">): ArtifactResolver;
+export declare function loadBundle(url: string, options?: SourceOptions): Promise<LoadedSource>;
+export declare function sourceFromBundle(bundle: UhdBundle, url: string, options?: SourceOptions): LoadedSource;

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

@@ -0,0 +1,45 @@
+/**
+ * A bundle that does not hold everything it names still draws.
+ *
+ * UHD's resolvers throw on a child whose definition is not in the bundle, and
+ * on a link or an export that names an interface nobody has. A producer that
+ * could not fetch some definitions (a library that was unreachable) writes
+ * exactly such a bundle, and the viewer drew nothing at all for it.
+ *
+ * `tolerantSystem` gives the viewer a system the resolvers accept: a missing
+ * definition is stood in for by a placeholder that has the interfaces its
+ * parents' links and exports name, and a link or an export that still cannot
+ * be resolved is left out. What was stood in for and what was left out is
+ * returned, so the views can say so.
+ */
+import type { ModuleDef } from "@deltarobotics/uhd";
+import { type ModuleLookup } from "@deltarobotics/uhd";
+/** A definition the bundle names and does not hold. */
+export interface MissingDefinition {
+    /** The definition id the children name. */
+    id: string;
+    /** Where it is used: the parent definition and the child's id and label there. */
+    usedBy: {
+        parent: string;
+        child: string;
+        name?: string;
+    }[];
+}
+/** A link or an export left out because it could not be resolved. */
+export interface LeftOut {
+    kind: "link" | "export";
+    /** The definition it was on. */
+    on: string;
+    id: string;
+    /** The resolver's message. */
+    why: string;
+}
+export interface TolerantSystem {
+    root: ModuleDef;
+    lookup: ModuleLookup;
+    missing: MissingDefinition[];
+    leftOut: LeftOut[];
+}
+/** Whether a definition is a placeholder for one the bundle does not hold. */
+export declare function isPlaceholder(def: ModuleDef | undefined): boolean;
+export declare function tolerantSystem(root: ModuleDef, lookup: ModuleLookup): TolerantSystem;