beckhoff-xts-viewer-3d 5.2.0 → 5.2.2

package/dist/index.d.cts

@@ -12,7 +12,7 @@ import { GLTF } from 'three-stdlib';
  * Run `npm run sync-version` (or any script that depends on it) to refresh
  * after bumping the package version.
  */
-declare const VERSION: "5.2.0";
+declare const VERSION: "5.2.2";
 
 /**
  * Default CDN URL for the GLB asset bundle (`beckhoff-xts-viewer-3d-assets`).
@@ -35,273 +35,14 @@ declare const VERSION: "5.2.0";
 declare const JSDELIVR_ASSETS_BASE_URL: "https://cdn.jsdelivr.net/npm/beckhoff-xts-viewer-3d-assets@2.0.1/models";
 
 /**
- * Public types for the measurement + annotation feature.
- *
- * Everything here is expressed in the viewer's WORLD frame — millimetres,
- * Z-up, identical to `XtsViewer3DRef.getMoverWorldTransform()` and
- * `CameraState.positionMm`. That is what makes one implementation serve both
- * the perspective 3D view and the orthographic 2D plan view
- * (`projection='orthographic'`): only the camera differs, the geometry does
- * not.
- */
-
-/**
- * How a measurement point was derived. `'free'` is the raw ray hit (surface
- * or ground plane); everything else is a snap the picker resolved to.
- */
-type SnapKind = 'free' | 'vertex' | 'edge-midpoint' | 'face-center' | 'grid' | 'mover-center' | 'module-boundary' | 'module-center' | 'station-stop' | 'track-path';
-/** Scene entity a picked point belongs to, when the picker could resolve one. */
-type MeasuredEntityRef = {
-    kind: 'module';
-    ref: ModuleRef;
-} | {
-    kind: 'mover';
-    ref: MoverRef;
-} | {
-    kind: 'station';
-    stationId: number;
-};
-/** A position on a part's track path, in the XPU's user position frame. */
-interface TrackAnchor {
-    processingUnitObjectId: number;
-    /** `PartConfig.objectId`. */
-    partObjectId: number;
-    /** Position along the part, user frame (same convention as movers). */
-    partPositionMm: number;
-}
-/** One measurement vertex. */
-interface MeasurementPoint {
-    /** World position (mm). */
-    positionMm: Vec3;
-    /** How the point was obtained. Default `'free'` when omitted. */
-    snap?: SnapKind;
-    /** Entity the point sits on, when known. */
-    entity?: MeasuredEntityRef;
-    /**
-     * Track position, set whenever the point resolved onto a part's path.
-     * Required on both endpoints of a `'trackDistance'` measurement.
-     */
-    track?: TrackAnchor;
-}
-/** Snapping configuration. */
-interface SnapOptions {
-    /** Master switch. Default `true`. */
-    enabled?: boolean;
-    /**
-     * Snap kinds to consider, highest priority first. Default:
-     * `['vertex', 'edge-midpoint', 'mover-center', 'module-boundary',
-     *   'station-stop', 'track-path', 'face-center']`.
-     */
-    kinds?: SnapKind[];
-    /** Screen-space radius (px) a candidate must fall within. Default `14`. */
-    radiusPx?: number;
-    /**
-     * Grid step (mm) for the `'grid'` snap, applied to the free hit point when
-     * no other candidate matched and `'grid'` is in `kinds`. Default `0` (off).
-     */
-    gridMm?: number;
-}
-type MeasurementId = string;
-type MeasurementKind = 'distance' | 'angle' | 'path' | 'trackDistance';
-/** Axis constraint for a distance measurement. */
-type MeasurementAxis = 'free' | 'x' | 'y' | 'z';
-interface MeasurementBase {
-    id: MeasurementId;
-    /** Optional caption rendered above the value. */
-    label?: string;
-    /** Overrides `MeasurementStyle.color` for this one measurement. */
-    color?: string;
-    /** Default `true`. */
-    visible?: boolean;
-    /** Free-form payload the host can round-trip (never read by the viewer). */
-    meta?: Record<string, unknown>;
-}
-/** Straight-line distance between two points. */
-interface DistanceMeasurement extends MeasurementBase {
-    kind: 'distance';
-    points: [MeasurementPoint, MeasurementPoint];
-    /** Constrain the reported value to one axis. Default `'free'`. */
-    axis?: MeasurementAxis;
-    /** Render dashed ΔX / ΔY / ΔZ guides. Default `false`. */
-    showComponents?: boolean;
-}
-/** Angle at `points[1]` between the legs to `points[0]` and `points[2]`. */
-interface AngleMeasurement extends MeasurementBase {
-    kind: 'angle';
-    /** `[legA, vertex, legB]` — the middle point is the vertex. */
-    points: [MeasurementPoint, MeasurementPoint, MeasurementPoint];
-}
-/** Polyline through N points; reports per-segment and total length. */
-interface PathMeasurement extends MeasurementBase {
-    kind: 'path';
-    points: MeasurementPoint[];
-    /** Close the polyline back to the first point. Default `false`. */
-    closed?: boolean;
-    /** Label every segment, not just the total. Default `true`. */
-    showSegmentLengths?: boolean;
-}
-/**
- * Distance ALONG the XTS track between two points on the same part — the
- * distance a mover actually travels, not the straight line.
- */
-interface TrackDistanceMeasurement extends MeasurementBase {
-    kind: 'trackDistance';
-    points: [MeasurementPoint, MeasurementPoint];
-}
-type Measurement = DistanceMeasurement | AngleMeasurement | PathMeasurement | TrackDistanceMeasurement;
-/** Same as `Measurement`, but the store generates the `id` when omitted. */
-type MeasurementInput = (Omit<DistanceMeasurement, 'id'> & {
-    id?: MeasurementId;
-}) | (Omit<AngleMeasurement, 'id'> & {
-    id?: MeasurementId;
-}) | (Omit<PathMeasurement, 'id'> & {
-    id?: MeasurementId;
-}) | (Omit<TrackDistanceMeasurement, 'id'> & {
-    id?: MeasurementId;
-});
-/** Computed value of a measurement. */
-interface MeasurementResult {
-    id: MeasurementId;
-    kind: MeasurementKind;
-    /** Millimetres for lengths, degrees for angles. */
-    value: number;
-    unit: 'mm' | 'deg';
-    /** Formatted value as rendered in the scene (e.g. `'1 234.5 mm'`). */
-    text: string;
-    /** Signed component deltas — `'distance'` only. */
-    deltaMm?: Vec3;
-    /** Per-segment lengths — `'path'` only. */
-    segmentLengthsMm?: number[];
-    /**
-     * `true` when the measurement could not be evaluated (e.g. a
-     * `trackDistance` whose endpoints sit on different parts). `value` is then
-     * the straight-line fallback.
-     */
-    incomplete?: boolean;
-}
-/** Where an annotation hangs. Mover anchors follow the live mover position. */
-type AnnotationAnchor = {
-    kind: 'world';
-    positionMm: Vec3;
-} | {
-    kind: 'mover';
-    ref: MoverRef;
-} | {
-    kind: 'module';
-    ref: ModuleRef;
-} | ({
-    kind: 'trackPosition';
-} & TrackAnchor);
-interface Annotation {
-    id: string;
-    text: string;
-    anchor: AnnotationAnchor;
-    /**
-     * Leader-line offset from the anchor to the label (mm, world frame).
-     * Default `[0, 0, 250]`.
-     */
-    offsetMm?: Vec3;
-    color?: string;
-    /** Text height (mm). Default `MeasurementStyle.labelSizeMm`. */
-    sizeMm?: number;
-    /** Marker drawn at the anchor. Default `'Sphere'`. */
-    markerShape?: MarkerShape;
-    markerSizeMm?: number;
-    /** Default `true`. */
-    visible?: boolean;
-    meta?: Record<string, unknown>;
-}
-type AnnotationInput = Omit<Annotation, 'id'> & {
-    id?: string;
-};
-type MeasurementTool = 'none' | 'distance' | 'angle' | 'path' | 'trackDistance' | 'annotation';
-/** In-progress pick. `null` while no tool is armed. */
-interface MeasurementDraft {
-    tool: Exclude<MeasurementTool, 'none'>;
-    /** Points committed so far. */
-    points: MeasurementPoint[];
-    /** Point currently under the cursor, or `null` when off the scene. */
-    hover: MeasurementPoint | null;
-}
-interface MeasurementStyle {
-    /** Line + label colour of committed measurements. Default `'#00E5FF'`. */
-    color?: string;
-    /** Colour of the in-progress draft. Default `'#FFC400'`. */
-    draftColor?: string;
-    /** Annotation colour. Default `'#FFFFFF'`. */
-    annotationColor?: string;
-    /** Line width in pixels. Default `2`. */
-    lineWidthPx?: number;
-    /** Text height (mm). Default `40`. */
-    labelSizeMm?: number;
-    /** Endpoint marker diameter (mm). Default `18`. */
-    pointSizeMm?: number;
-    /** Decimal places on values. Default `1`. */
-    decimals?: number;
-    /** Unit suffix appended to lengths. Default `' mm'`. */
-    unitSuffix?: string;
-    /** Font URL passed to troika (see `DEFAULT_LABEL_FONT_URL`). */
-    fontFamily?: string;
-    /**
-     * Draw measurement lines and markers through solid geometry
-     * (`depthTest: false`). Default `true` — CAD viewers keep dimensions
-     * readable regardless of what is in front of them.
-     */
-    alwaysOnTop?: boolean;
-}
-/** Serializable snapshot of everything the measurement feature holds. */
-interface MeasurementDocument {
-    schemaVersion: 1;
-    measurements: Measurement[];
-    annotations: Annotation[];
-}
-/**
- * `measurement` prop of `<XtsViewer3D>`. Data can be driven either
- * declaratively (`measurements` / `annotations` — controlled arrays) or
- * imperatively via `viewerRef.current.measurements`. When the controlled
- * arrays are supplied they win on every render, so a host that uses them must
- * persist what the change callbacks report.
- */
-interface MeasurementOptions {
-    /** Armed tool. Default `'none'` — no picking, no cursor change. */
-    tool?: MeasurementTool;
-    /** Controlled measurement list. Omit to let the viewer keep its own. */
-    measurements?: MeasurementInput[];
-    /** Controlled annotation list. Omit to let the viewer keep its own. */
-    annotations?: AnnotationInput[];
-    snap?: SnapOptions;
-    style?: MeasurementStyle;
-    /**
-     * Z of the fallback pick plane (mm) used when the ray misses all geometry,
-     * so free space can be measured. Default `0`; `null` disables the fallback.
-     */
-    groundPlaneZMm?: number | null;
-    /** Fired after every change to the measurement list. */
-    onMeasurementsChange?: (measurements: Measurement[], results: MeasurementResult[]) => void;
-    /** Fired once when a tool completes a measurement. */
-    onMeasurementCreate?: (measurement: Measurement, result: MeasurementResult) => void;
-    onAnnotationsChange?: (annotations: Annotation[]) => void;
-    onAnnotationCreate?: (annotation: Annotation) => void;
-    /** Fired on every draft change (point added, hover moved, cancelled). */
-    onDraftChange?: (draft: MeasurementDraft | null) => void;
-    /**
-     * Text for an annotation the `'annotation'` tool just placed. Return
-     * `null` to abort. Default: `'Annotation'`.
-     */
-    annotationTextFactory?: (point: MeasurementPoint) => string | null;
-}
-
-/**
- * Public type surface for beckhoff-xts-viewer-3d.
+ * Catalogue taxonomy — the string unions naming every module, mover, tool and
+ * guiding-rail the viewer can render.
  *
- * Anything that crosses the Component boundary — props, refs, callbacks —
- * is declared here.
- *
- * The measurement feature keeps its own public types next to its
- * implementation (`measurement/types.ts`); only the serialized document shows
- * up here, as part of `XtsModelDocument`.
+ * These are the identifiers the asset pipeline, the geometry catalogues
+ * (`geometry/ModuleCatalog`, `geometry/MoverCatalog`) and the sidecar files
+ * all key off, so they are the narrowest and most-depended-on part of the
+ * public type surface. Nothing here imports anything.
  */
-
 /** Beckhoff XTS module types supported by the 3D viewer. */
 type ModuleType3D = 'AT2000_0250' | 'AT2001_0250' | 'AT2002_0250' | 'AT2002_0249' | 'AT2002_0249_ZX2002_0001' | 'AT2000_0233' | 'AT2000_0249' | 'AT2100_0250' | 'AT2102_0250' | 'AT2020_0250' | 'AT2021_0250' | 'AT2025_0250' | 'AT2026_0250' | 'AT2040_0250' | 'AT2041_0250' | 'AT2042_0250' | 'AT2140_0250' | 'AT2050_0500' | 'AT2050_0501' | 'AT2050_0500_180' | 'AT2200_0500' | 'AT2202_0500' | 'ATH2000_0250' | 'ATH2001_0250' | 'ATH2002_0250' | 'ATH2020_0250' | 'ATH2040_0250' | 'ATH2041_0250' | 'ATH2042_0250' | 'ATH2050_0500' | 'ATH2050_0501' | 'ATH2050_0500_180';
 /**
@@ -343,313 +84,28 @@ type MoverToolType3D = 'AT8200_1000_0100' | 'AT8200_2000_0100' | 'Custom';
  * GLB and therefore do NOT receive a separate guiding-rail mesh.
  */
 type RailType3D = 'AT9000_0249' | 'AT9000_0250' | 'AT9000_0500' | 'AT9020_1250' | 'AT9025_1466' | 'AT9040_0750' | 'AT9050_0500';
-type Vec3 = [number, number, number];
-type Vec2 = [number, number];
-/** Pose of the entire XTS group in the world frame. */
-interface Orientation {
-    positionMm?: Vec3;
-    /** Intrinsic XYZ Euler angles in degrees. */
-    rotationDegEuler?: Vec3;
-}
-/**
- * Per-part heatmap samples plus colour range. Rendered as a coloured
- * tube running along each part's centerline (with optional lateral /
- * vertical offset), with the tube's vertex colours interpolated between
- * `minColor` and `maxColor` according to the consumer-supplied
- * `(positionMm, value)` samples.
- *
- * Typical use: per-stator drive current, motor temperature, or fault
- * counters streamed from the controller and overlaid on the layout in
- * real time. Sample positions are interpreted in the XPU's user-frame
- * (`ProcessingUnitConfig.positionFrame`), same convention as mover /
- * station / area positions.
- */
-interface StatorHeatmap {
-    /**
-     * One bucket per `PartConfig.globalNumber`. Parts not listed render
-     * no heatmap. Samples within a part are sorted by `positionMm`
-     * before interpolation; values between consecutive samples are
-     * linearly interpolated, values outside the sample range are
-     * held flat at the nearest sample.
-     */
-    parts: Array<{
-        partOid: number;
-        samples: Array<{
-            positionMm: number;
-            value: number;
-        }>;
-    }>;
-    /** Value mapped to `minColor`. Values ≤ min clamp to `minColor`. */
-    min: number;
-    /** Value mapped to `maxColor`. Values ≥ max clamp to `maxColor`. */
-    max: number;
-    /** Colour at `min`. Default `'#22c55e'` (green). */
-    minColor?: string;
-    /** Colour at `max`. Default `'#ef4444'` (red). */
-    maxColor?: string;
-    /** Tube thickness in mm. Default 6. */
-    thicknessMm?: number;
-    /** Vertical Z lift (mm). Default -15 — sits just below the rail. */
-    displacementMm?: number;
-    /** Lateral Y displacement (mm). Default 0. */
-    lateralDisplacementMm?: number;
-    /**
-     * Path segments per module along the heatmap tube. More = smoother
-     * gradient, more triangles. Default 8 (= 32 segments on a 4-module
-     * straight, ~1 GPU vertex per 8 mm of track).
-     */
-    segmentsPerModule?: number;
-    /** Tube opacity (0..1). Default 0.85. */
-    opacity?: number;
-}
-interface XtsConfig {
-    orientation?: Orientation;
-    processingUnits: ProcessingUnitConfig[];
-    stations?: StationConfig[];
-    /**
-     * Labelled regions along the track. Like a StationConfig, but
-     * without stop positions — only a coloured tube segment plus an
-     * optional description billboard. For zone markings (e.g. "Manual
-     * Access", "Safety Area", "Cleanroom") that have no
-     * machine stops.
-     */
-    areas?: AreaConfig[];
-    infoBars?: InfoBarConfig[];
-    customAssets?: CustomAssetConfig[];
-}
-interface ProcessingUnitConfig {
-    /**
-     * Stable host-supplied 32-bit unique identifier for this XPU. Required
-     * at runtime — must be a non-negative integer that fits in a uint32
-     * and is unique across all XPUs in the config.
-     */
-    objectId: number;
-    moverType: MoverType3D;
-    customMoverLayout?: CustomMoverLayout;
-    /** Default: 'Beckhoff'. */
-    railSystem?: RailSystem;
-    parts: PartConfig[];
-    movers: MoverConfig[];
-    /**
-     * Track-level pose, applied to the entire XPU subtree (modules, movers,
-     * tools, stations, info bars, mover-bound custom assets). Composes
-     * MULTIPLICATIVELY with the root `XtsConfig.orientation`:
-     *
-     *     world = orientation ⊗ trackTransform ⊗ partTransformation ⊗ chain
-     *
-     * `scaleUniform` is applied as a uniform scale factor (default 1). Non-
-     * uniform scaling is intentionally not supported — it would distort path
-     * radii and break GLB lighting.
-     */
-    trackTransform?: TrackTransform;
-    /**
-     * User-frame remap applied to every `partPositionMm`-style value inside
-     * this XPU (mover positions, station start/end/stops, area start/end,
-     * stop-position ghost movers). Lets a host that uses a different "zero"
-     * or sign convention than the GLB chain enter positions in their own
-     * frame; the renderer translates to the chain's intrinsic frame:
-     *
-     *     chainPos = originMm + (direction === 'negative' ? -userPos : userPos)
-     *
-     * Defaults: `direction: 'positive'`, `originMm: 0` — i.e. user-frame
-     * equals chain-frame, no transform.
-     */
-    positionFrame?: PositionFrame;
-}
-/**
- * Sign + zero-offset convention for partPosition values within an XPU.
- * See `ProcessingUnitConfig.positionFrame` for semantics.
- */
-interface PositionFrame {
-    /** Travel direction. Default: `'positive'`. */
-    direction?: 'positive' | 'negative';
-    /** Zero-point shift (in chain-coordinates mm). Default: 0. */
-    originMm?: number;
-}
-interface TrackTransform {
-    positionMm?: Vec3;
-    /** Intrinsic XYZ Euler angles in degrees. */
-    rotationDegEuler?: Vec3;
-    /** Uniform scale factor. Default 1. */
-    scaleUniform?: number;
-    /** Hide the entire XPU when false. Default true. */
-    visible?: boolean;
-}
-interface PartConfig {
-    /**
-     * Stable host-supplied 32-bit unique identifier for this part. Distinct
-     * from `globalNumber` (server-side ObjectId): callers reference parts
-     * by `objectId` at runtime — e.g. in the array form of
-     * `XtsViewer3DRef.setMoverPositions` (`{partObjectId, partPosition}`).
-     * Required at runtime — must be a non-negative integer that fits in a
-     * uint32 and is unique across all parts in the system.
-     * `normalizeXtsConfig` emits a `missing-part-object-id` /
-     * `invalid-part-object-id` / `duplicate-part-object-id` warning when
-     * the contract is violated.
-     */
-    objectId: number;
-    /** = ServerTypes.PartModel.ObjectId — unique system-wide. */
-    globalNumber: number;
-    modules: ModuleEntry[];
-    partTransformation?: PartTransformation;
-}
-interface ModuleEntry {
-    moduleType: ModuleType3D;
-    /**
-     * Stable host-supplied number for this module. Required at runtime —
-     * simply counted up per module (1, 2, 3, …) across the whole system
-     * and used as the index in `XtsViewer3DRef.setModuleStatuses(array)` —
-     * i.e. `statuses[m.globalNumber] === { warning?: …, error?: … }`.
-     * `normalizeXtsConfig` emits a `missing-module-global-number` /
-     * `invalid-module-global-number` / `duplicate-module-global-number`
-     * warning when the contract is violated. Typed optional only so
-     * legacy configs and tests keep compiling; new code MUST set it.
-     */
-    globalNumber?: number;
-    /**
-     * Optional drive-status overlay for this module. Mirrors the
-     * `MoverConfig.status` shape; the same per-mesh emissive blink +
-     * billboard <DriveStatusIcon> surfaces both. Filtered by
-     * `display.showDriveWarnings` / `display.showDriveErrors`.
-     *
-     * For live updates (e.g. drive warnings/errors streamed from PLC),
-     * prefer the imperative
-     * `XtsViewer3DRef.setModuleStatuses(array)` channel — index = this
-     * module's `globalNumber`. The store wins over this config-time value.
-     */
-    status?: {
-        warning?: boolean;
-        error?: boolean;
-    };
-}
+
 /**
- * Per-part 3D pose, applied to EVERYTHING anchored to the part:
- * modules, guiding rails, movers, mover tools, mover-bound custom assets,
- * and the path-derived overlays (stations, areas, dimensions, info bars,
- * stop-position ghost movers, stator heatmap). Composes inside the
- * per-XPU `trackTransform`:
- *
- *     world = orientation ⊗ trackTransform ⊗ partTransformation ⊗ chain
- *
- * All fields are optional and default to identity (offset = [0,0,0],
- * rotation = [0,0,0]). Whole-track placement is done via
- * `ProcessingUnitConfig.trackTransform`; this transform is for moving a
- * part WITHIN its XPU — e.g. lifts that translate along Z, parts
- * mounted at an angle, or live-editable kinematics in the playground.
+ * Scalar tuples shared by every other type module.
  *
- * Multi-part overlays (stations / areas spanning multiple `partOids`)
- * follow the transform of their FIRST partOid — the chain math
- * upstream is part-local, and points from differently-transformed
- * parts can't be stitched into a single tube. Anchor multi-part
- * overlays to the part you want them to track.
+ * The leaf of the type graph: `Vec3` is a position or an Euler triple in
+ * millimetres / degrees, `Vec2` a viewport or margin pair in pixels. Kept
+ * apart from the layout types so `display`, `annotations` and `config` can
+ * all reach them without importing each other.
  */
-interface PartTransformation {
-    /** Translation in mm, in the XPU's track-transform frame. */
-    offsetMm?: Vec3;
-    /** Intrinsic XYZ Euler angles in degrees. */
-    rotationDegEuler?: Vec3;
-    partSide?: 'Default' | 'Driver' | 'Encoder';
-    /** Hide everything on this part when false. Default true. */
-    visible?: boolean;
-}
-interface MoverConfig {
-    /** Position-on-track index within the XPU. */
-    index: number;
-    /**
-     * Stable host-supplied 32-bit unique identifier for this mover.
-     * Required, must be a non-negative integer that fits in a uint32 and
-     * is unique across all movers in the config.
-     */
-    id: number;
-    /** References PartConfig.globalNumber. */
-    partOid: number;
-    /** [0, part.trackLengthMm] — clamped when out-of-bounds. */
-    partPositionMm: number;
-    status?: {
-        warning?: boolean;
-        error?: boolean;
-    };
-    selected?: boolean;
-    /** Predefined tool carriers or custom GLBs attached to this mover. */
-    tools?: MoverToolConfig[];
-}
-/**
- * Runtime mover-position update entry — pushed through
- * `XtsViewer3DRef.setMoverPositions(array)`. The array is indexed by
- * `MoverConfig.index` (i.e. entry `i` targets the mover with
- * `index === i`); use `null` / `undefined` to skip a slot. The
- * `partObjectId` field references `PartConfig.objectId`.
- */
-interface MoverPositionEntry {
-    /** = PartConfig.objectId (the host-side 32-bit unique part ID). */
-    partObjectId: number;
-    /** Position along the referenced part, in user-frame mm. */
-    partPosition: number;
-}
-/**
- * Runtime drive-status entry for a single module — pushed through
- * `XtsViewer3DRef.setModuleStatuses(array)`. The array is indexed by
- * `ModuleEntry.globalNumber`; use `null` / `undefined` to clear a slot.
+type Vec3 = [number, number, number];
+type Vec2 = [number, number];
+
+/**
+ * Display options — how a layout is drawn, as opposed to what it is.
+ *
+ * Everything reachable from the `display` prop: visibility toggles, lighting
+ * and post-processing, and the per-overlay styling blocks (`StationOptions`,
+ * `AreaOptions`, `DimensionOptions`, …). The overlays these style are declared
+ * as configuration in `annotations.ts`; nothing here changes the layout, only
+ * its appearance.
  */
-interface ModuleStatusEntry {
-    warning?: boolean;
-    error?: boolean;
-}
-interface MoverToolConfig {
-    toolType: MoverToolType3D;
-    /** Required when toolType === 'Custom'. */
-    customGlbUrl?: string;
-    customOriginCorrection?: {
-        translateMm: Vec3;
-        rotationDegEuler: Vec3;
-    };
-    /** Local placement on the mover, relative to the magnet-plate center. */
-    offsetMm?: Vec3;
-    rotationDegEuler?: Vec3;
-    opacity?: number;
-    visible?: boolean;
-    id?: string;
-}
-interface CustomMoverLayout {
-    glbUrl: string;
-    originCorrection?: {
-        translateMm: Vec3;
-        rotationDegEuler: Vec3;
-    };
-    magnetPlateCenterMm?: Vec3;
-    pathLengthMm?: number;
-    imageFrontUrl?: string;
-    imageBackUrl?: string;
-}
-type CustomAssetBinding = {
-    type: 'static';
-    positionMm: Vec3;
-    rotationDegEuler: Vec3;
-    scale?: number;
-} | {
-    type: 'mover';
-    moverRef: {
-        processingUnitObjectId: number;
-        moverIndex: number;
-    };
-    offsetMm?: Vec3;
-    rotationDegEuler?: Vec3;
-    /** Uniform scale (default 1). */
-    scale?: number;
-} | {
-    type: 'all-movers';
-    offsetMm?: Vec3;
-    rotationDegEuler?: Vec3;
-    /** Uniform scale (default 1). Applied per mover. */
-    scale?: number;
-};
-interface CustomAssetConfig {
-    id: string;
-    glbUrl: string;
-    binding: CustomAssetBinding;
-    opacity?: number;
-    visible?: boolean;
-}
+
 /**
  * Y-axis / rotation convention for incoming position data.
  *
@@ -1024,101 +480,436 @@ interface DimensionOptions {
      * Whether intermediate ticks also get value labels. Only applies when
      * `showValues` is true. Default: true.
      */
-    showIntermediateValues?: boolean;
+    showIntermediateValues?: boolean;
+    /**
+     * What number to display next to each tick:
+     *   - 'partPosition' (default): cumulative mm from the part's start.
+     *   - 'fromModule'  : mm from the start of the containing module.
+     *   - 'both'        : "<part> mm (<module> mm)".
+     */
+    valueMode?: 'partPosition' | 'fromModule' | 'both';
+}
+interface InfoBarOptions {
+    defaultThicknessMm?: number;
+    textOptions?: TextOptions;
+}
+interface TextOptions {
+    sizeMm?: number;
+    color?: string;
+    fontFamily?: string;
+}
+
+/**
+ * Track annotations — stations, areas and info bars.
+ *
+ * Regions and labels a host places along the track. They are configuration,
+ * not geometry: each is anchored to part object ids and positions on those
+ * parts, and the renderer resolves them against the built chain. How they are
+ * styled lives in `display.ts`.
+ */
+
+interface StationConfig {
+    stationId: number;
+    description: string;
+    isEnabled: boolean;
+    partOids: number[];
+    startPositionOnPart: number;
+    endPositionOnPart: number;
+    /** ARGB int (same as 2D). */
+    stationColor: number;
+    stopPositions?: number[];
+    /**
+     * Reference frame for `stopPositions` values:
+     *   - `'track'`   (default) — values are absolute partPositionMm from
+     *                              track start. Same convention as
+     *                              `startPositionOnPart` / `endPositionOnPart`.
+     *   - `'station'` — values are RELATIVE to `startPositionOnPart`. So
+     *                   `0` puts a stop right at the station's start;
+     *                   `100` puts one 100 mm into the station regardless
+     *                   of where the station lives on the part.
+     *
+     * Useful when stops are conceptually tied to the station's geometry
+     * (entry, mid, exit) rather than absolute mm marks on the track.
+     */
+    stopPositionsRelativeTo?: 'track' | 'station';
+    /**
+     * Per-station override of the stop-marker geometry. Falls back to
+     * `display.stationMarkerOptions.shape` when omitted. Lets one station
+     * render Diamonds while a neighbour uses Cones, etc.
+     */
+    stopMarkerShape?: MarkerShape;
+    /** Per-station override of the stop-marker size (mm). */
+    stopMarkerSizeMm?: number;
+}
+/**
+ * Labelled region along the track. Identical to
+ * `StationConfig`, but without stop positions — areas only carry text +
+ * colour and describe a zone (e.g. "Cleanroom", "Manual Access",
+ * "Safety Loop") that does not trigger machine stops.
+ *
+ * Multi-part: same semantics as `StationConfig.partOids`. With a single
+ * partOid and `endPositionOnPart < startPositionOnPart`, a closed loop
+ * is rendered (to the end of the track, then from 0 to End).
+ */
+interface AreaConfig {
+    areaId: number;
+    description: string;
+    isEnabled: boolean;
+    partOids: number[];
+    startPositionOnPart: number;
+    endPositionOnPart: number;
+    /** ARGB int (same as StationConfig). Used for tube + default label. */
+    color: number;
+}
+interface InfoBarConfig {
+    processingUnitObjectId: number;
+    partObjectId: number;
+    partStartPositionMm: number;
+    partEndPositionMm: number;
+    thickness: number;
+    displacement: number;
+    color: {
+        color: string;
+    };
+    visible: boolean;
+    text?: string;
+    textPlacement?: 'Left' | 'Center' | 'Right';
+    textDisplacement?: number;
+    textOptions?: TextOptions;
+    markers?: InfoBarMarkerConfig[];
+    zIndex: number;
+}
+interface InfoBarMarkerConfig {
+    positionMm: number;
+    shape: 'Diamond' | 'Tick' | 'None';
+    sizeMm: number;
+    color?: string;
+}
+
+/**
+ * The configuration tree — what a host hands `<XtsViewer3D config={...}>`.
+ *
+ * `XtsConfig` down through processing units, parts, modules and movers: the
+ * description of a physical layout, independent of how it is drawn. Rendering
+ * preferences live in `display.ts`, and the overlays placed on top of a layout
+ * (stations, areas, info bars) in `annotations.ts`.
+ */
+
+/** Pose of the entire XTS group in the world frame. */
+interface Orientation {
+    positionMm?: Vec3;
+    /** Intrinsic XYZ Euler angles in degrees. */
+    rotationDegEuler?: Vec3;
+}
+/**
+ * Per-part heatmap samples plus colour range. Rendered as a coloured
+ * tube running along each part's centerline (with optional lateral /
+ * vertical offset), with the tube's vertex colours interpolated between
+ * `minColor` and `maxColor` according to the consumer-supplied
+ * `(positionMm, value)` samples.
+ *
+ * Typical use: per-stator drive current, motor temperature, or fault
+ * counters streamed from the controller and overlaid on the layout in
+ * real time. Sample positions are interpreted in the XPU's user-frame
+ * (`ProcessingUnitConfig.positionFrame`), same convention as mover /
+ * station / area positions.
+ */
+interface StatorHeatmap {
+    /**
+     * One bucket per `PartConfig.globalNumber`. Parts not listed render
+     * no heatmap. Samples within a part are sorted by `positionMm`
+     * before interpolation; values between consecutive samples are
+     * linearly interpolated, values outside the sample range are
+     * held flat at the nearest sample.
+     */
+    parts: Array<{
+        partOid: number;
+        samples: Array<{
+            positionMm: number;
+            value: number;
+        }>;
+    }>;
+    /** Value mapped to `minColor`. Values ≤ min clamp to `minColor`. */
+    min: number;
+    /** Value mapped to `maxColor`. Values ≥ max clamp to `maxColor`. */
+    max: number;
+    /** Colour at `min`. Default `'#22c55e'` (green). */
+    minColor?: string;
+    /** Colour at `max`. Default `'#ef4444'` (red). */
+    maxColor?: string;
+    /** Tube thickness in mm. Default 6. */
+    thicknessMm?: number;
+    /** Vertical Z lift (mm). Default -15 — sits just below the rail. */
+    displacementMm?: number;
+    /** Lateral Y displacement (mm). Default 0. */
+    lateralDisplacementMm?: number;
+    /**
+     * Path segments per module along the heatmap tube. More = smoother
+     * gradient, more triangles. Default 8 (= 32 segments on a 4-module
+     * straight, ~1 GPU vertex per 8 mm of track).
+     */
+    segmentsPerModule?: number;
+    /** Tube opacity (0..1). Default 0.85. */
+    opacity?: number;
+}
+interface XtsConfig {
+    orientation?: Orientation;
+    processingUnits: ProcessingUnitConfig[];
+    stations?: StationConfig[];
+    /**
+     * Labelled regions along the track. Like a StationConfig, but
+     * without stop positions — only a coloured tube segment plus an
+     * optional description billboard. For zone markings (e.g. "Manual
+     * Access", "Safety Area", "Cleanroom") that have no
+     * machine stops.
+     */
+    areas?: AreaConfig[];
+    infoBars?: InfoBarConfig[];
+    customAssets?: CustomAssetConfig[];
+}
+interface ProcessingUnitConfig {
+    /**
+     * Stable host-supplied 32-bit unique identifier for this XPU. Required
+     * at runtime — must be a non-negative integer that fits in a uint32
+     * and is unique across all XPUs in the config.
+     */
+    objectId: number;
+    moverType: MoverType3D;
+    customMoverLayout?: CustomMoverLayout;
+    /** Default: 'Beckhoff'. */
+    railSystem?: RailSystem;
+    parts: PartConfig[];
+    movers: MoverConfig[];
+    /**
+     * Track-level pose, applied to the entire XPU subtree (modules, movers,
+     * tools, stations, info bars, mover-bound custom assets). Composes
+     * MULTIPLICATIVELY with the root `XtsConfig.orientation`:
+     *
+     *     world = orientation ⊗ trackTransform ⊗ partTransformation ⊗ chain
+     *
+     * `scaleUniform` is applied as a uniform scale factor (default 1). Non-
+     * uniform scaling is intentionally not supported — it would distort path
+     * radii and break GLB lighting.
+     */
+    trackTransform?: TrackTransform;
     /**
-     * What number to display next to each tick:
-     *   - 'partPosition' (default): cumulative mm from the part's start.
-     *   - 'fromModule'  : mm from the start of the containing module.
-     *   - 'both'        : "<part> mm (<module> mm)".
+     * User-frame remap applied to every `partPositionMm`-style value inside
+     * this XPU (mover positions, station start/end/stops, area start/end,
+     * stop-position ghost movers). Lets a host that uses a different "zero"
+     * or sign convention than the GLB chain enter positions in their own
+     * frame; the renderer translates to the chain's intrinsic frame:
+     *
+     *     chainPos = originMm + (direction === 'negative' ? -userPos : userPos)
+     *
+     * Defaults: `direction: 'positive'`, `originMm: 0` — i.e. user-frame
+     * equals chain-frame, no transform.
      */
-    valueMode?: 'partPosition' | 'fromModule' | 'both';
+    positionFrame?: PositionFrame;
 }
-interface InfoBarOptions {
-    defaultThicknessMm?: number;
-    textOptions?: TextOptions;
+/**
+ * Sign + zero-offset convention for partPosition values within an XPU.
+ * See `ProcessingUnitConfig.positionFrame` for semantics.
+ */
+interface PositionFrame {
+    /** Travel direction. Default: `'positive'`. */
+    direction?: 'positive' | 'negative';
+    /** Zero-point shift (in chain-coordinates mm). Default: 0. */
+    originMm?: number;
 }
-interface TextOptions {
-    sizeMm?: number;
-    color?: string;
-    fontFamily?: string;
+interface TrackTransform {
+    positionMm?: Vec3;
+    /** Intrinsic XYZ Euler angles in degrees. */
+    rotationDegEuler?: Vec3;
+    /** Uniform scale factor. Default 1. */
+    scaleUniform?: number;
+    /** Hide the entire XPU when false. Default true. */
+    visible?: boolean;
 }
-interface StationConfig {
-    stationId: number;
-    description: string;
-    isEnabled: boolean;
-    partOids: number[];
-    startPositionOnPart: number;
-    endPositionOnPart: number;
-    /** ARGB int (same as 2D). */
-    stationColor: number;
-    stopPositions?: number[];
+interface PartConfig {
     /**
-     * Reference frame for `stopPositions` values:
-     *   - `'track'`   (default) — values are absolute partPositionMm from
-     *                              track start. Same convention as
-     *                              `startPositionOnPart` / `endPositionOnPart`.
-     *   - `'station'` — values are RELATIVE to `startPositionOnPart`. So
-     *                   `0` puts a stop right at the station's start;
-     *                   `100` puts one 100 mm into the station regardless
-     *                   of where the station lives on the part.
-     *
-     * Useful when stops are conceptually tied to the station's geometry
-     * (entry, mid, exit) rather than absolute mm marks on the track.
+     * Stable host-supplied 32-bit unique identifier for this part. Distinct
+     * from `globalNumber` (server-side ObjectId): callers reference parts
+     * by `objectId` at runtime — e.g. in the array form of
+     * `XtsViewer3DRef.setMoverPositions` (`{partObjectId, partPosition}`).
+     * Required at runtime — must be a non-negative integer that fits in a
+     * uint32 and is unique across all parts in the system.
+     * `normalizeXtsConfig` emits a `missing-part-object-id` /
+     * `invalid-part-object-id` / `duplicate-part-object-id` warning when
+     * the contract is violated.
      */
-    stopPositionsRelativeTo?: 'track' | 'station';
+    objectId: number;
+    /** = ServerTypes.PartModel.ObjectId — unique system-wide. */
+    globalNumber: number;
+    modules: ModuleEntry[];
+    partTransformation?: PartTransformation;
+}
+interface ModuleEntry {
+    moduleType: ModuleType3D;
     /**
-     * Per-station override of the stop-marker geometry. Falls back to
-     * `display.stationMarkerOptions.shape` when omitted. Lets one station
-     * render Diamonds while a neighbour uses Cones, etc.
+     * Stable host-supplied number for this module. Required at runtime —
+     * simply counted up per module (1, 2, 3, …) across the whole system
+     * and used as the index in `XtsViewer3DRef.setModuleStatuses(array)` —
+     * i.e. `statuses[m.globalNumber] === { warning?: …, error?: … }`.
+     * `normalizeXtsConfig` emits a `missing-module-global-number` /
+     * `invalid-module-global-number` / `duplicate-module-global-number`
+     * warning when the contract is violated. Typed optional only so
+     * legacy configs and tests keep compiling; new code MUST set it.
      */
-    stopMarkerShape?: MarkerShape;
-    /** Per-station override of the stop-marker size (mm). */
-    stopMarkerSizeMm?: number;
+    globalNumber?: number;
+    /**
+     * Optional drive-status overlay for this module. Mirrors the
+     * `MoverConfig.status` shape; the same per-mesh emissive blink +
+     * billboard <DriveStatusIcon> surfaces both. Filtered by
+     * `display.showDriveWarnings` / `display.showDriveErrors`.
+     *
+     * For live updates (e.g. drive warnings/errors streamed from PLC),
+     * prefer the imperative
+     * `XtsViewer3DRef.setModuleStatuses(array)` channel — index = this
+     * module's `globalNumber`. The store wins over this config-time value.
+     */
+    status?: {
+        warning?: boolean;
+        error?: boolean;
+    };
 }
 /**
- * Labelled region along the track. Identical to
- * `StationConfig`, but without stop positions — areas only carry text +
- * colour and describe a zone (e.g. "Cleanroom", "Manual Access",
- * "Safety Loop") that does not trigger machine stops.
+ * Per-part 3D pose, applied to EVERYTHING anchored to the part:
+ * modules, guiding rails, movers, mover tools, mover-bound custom assets,
+ * and the path-derived overlays (stations, areas, dimensions, info bars,
+ * stop-position ghost movers, stator heatmap). Composes inside the
+ * per-XPU `trackTransform`:
  *
- * Multi-part: same semantics as `StationConfig.partOids`. With a single
- * partOid and `endPositionOnPart < startPositionOnPart`, a closed loop
- * is rendered (to the end of the track, then from 0 to End).
+ *     world = orientation ⊗ trackTransform ⊗ partTransformation ⊗ chain
+ *
+ * All fields are optional and default to identity (offset = [0,0,0],
+ * rotation = [0,0,0]). Whole-track placement is done via
+ * `ProcessingUnitConfig.trackTransform`; this transform is for moving a
+ * part WITHIN its XPU — e.g. lifts that translate along Z, parts
+ * mounted at an angle, or live-editable kinematics in the playground.
+ *
+ * Multi-part overlays (stations / areas spanning multiple `partOids`)
+ * follow the transform of their FIRST partOid — the chain math
+ * upstream is part-local, and points from differently-transformed
+ * parts can't be stitched into a single tube. Anchor multi-part
+ * overlays to the part you want them to track.
  */
-interface AreaConfig {
-    areaId: number;
-    description: string;
-    isEnabled: boolean;
-    partOids: number[];
-    startPositionOnPart: number;
-    endPositionOnPart: number;
-    /** ARGB int (same as StationConfig). Used for tube + default label. */
-    color: number;
+interface PartTransformation {
+    /** Translation in mm, in the XPU's track-transform frame. */
+    offsetMm?: Vec3;
+    /** Intrinsic XYZ Euler angles in degrees. */
+    rotationDegEuler?: Vec3;
+    partSide?: 'Default' | 'Driver' | 'Encoder';
+    /** Hide everything on this part when false. Default true. */
+    visible?: boolean;
 }
-interface InfoBarConfig {
-    processingUnitObjectId: number;
+interface MoverConfig {
+    /** Position-on-track index within the XPU. */
+    index: number;
+    /**
+     * Stable host-supplied 32-bit unique identifier for this mover.
+     * Required, must be a non-negative integer that fits in a uint32 and
+     * is unique across all movers in the config.
+     */
+    id: number;
+    /** References PartConfig.globalNumber. */
+    partOid: number;
+    /** [0, part.trackLengthMm] — clamped when out-of-bounds. */
+    partPositionMm: number;
+    status?: {
+        warning?: boolean;
+        error?: boolean;
+    };
+    selected?: boolean;
+    /** Predefined tool carriers or custom GLBs attached to this mover. */
+    tools?: MoverToolConfig[];
+}
+/**
+ * Runtime mover-position update entry — pushed through
+ * `XtsViewer3DRef.setMoverPositions(array)`. The array is indexed by
+ * `MoverConfig.index` (i.e. entry `i` targets the mover with
+ * `index === i`); use `null` / `undefined` to skip a slot. The
+ * `partObjectId` field references `PartConfig.objectId`.
+ */
+interface MoverPositionEntry {
+    /** = PartConfig.objectId (the host-side 32-bit unique part ID). */
     partObjectId: number;
-    partStartPositionMm: number;
-    partEndPositionMm: number;
-    thickness: number;
-    displacement: number;
-    color: {
-        color: string;
+    /** Position along the referenced part, in user-frame mm. */
+    partPosition: number;
+}
+/**
+ * Runtime drive-status entry for a single module — pushed through
+ * `XtsViewer3DRef.setModuleStatuses(array)`. The array is indexed by
+ * `ModuleEntry.globalNumber`; use `null` / `undefined` to clear a slot.
+ */
+interface ModuleStatusEntry {
+    warning?: boolean;
+    error?: boolean;
+}
+interface MoverToolConfig {
+    toolType: MoverToolType3D;
+    /** Required when toolType === 'Custom'. */
+    customGlbUrl?: string;
+    customOriginCorrection?: {
+        translateMm: Vec3;
+        rotationDegEuler: Vec3;
     };
-    visible: boolean;
-    text?: string;
-    textPlacement?: 'Left' | 'Center' | 'Right';
-    textDisplacement?: number;
-    textOptions?: TextOptions;
-    markers?: InfoBarMarkerConfig[];
-    zIndex: number;
+    /** Local placement on the mover, relative to the magnet-plate center. */
+    offsetMm?: Vec3;
+    rotationDegEuler?: Vec3;
+    opacity?: number;
+    visible?: boolean;
+    id?: string;
 }
-interface InfoBarMarkerConfig {
-    positionMm: number;
-    shape: 'Diamond' | 'Tick' | 'None';
-    sizeMm: number;
-    color?: string;
+interface CustomMoverLayout {
+    glbUrl: string;
+    originCorrection?: {
+        translateMm: Vec3;
+        rotationDegEuler: Vec3;
+    };
+    magnetPlateCenterMm?: Vec3;
+    pathLengthMm?: number;
+    imageFrontUrl?: string;
+    imageBackUrl?: string;
+}
+type CustomAssetBinding = {
+    type: 'static';
+    positionMm: Vec3;
+    rotationDegEuler: Vec3;
+    scale?: number;
+} | {
+    type: 'mover';
+    moverRef: {
+        processingUnitObjectId: number;
+        moverIndex: number;
+    };
+    offsetMm?: Vec3;
+    rotationDegEuler?: Vec3;
+    /** Uniform scale (default 1). */
+    scale?: number;
+} | {
+    type: 'all-movers';
+    offsetMm?: Vec3;
+    rotationDegEuler?: Vec3;
+    /** Uniform scale (default 1). Applied per mover. */
+    scale?: number;
+};
+interface CustomAssetConfig {
+    id: string;
+    glbUrl: string;
+    binding: CustomAssetBinding;
+    opacity?: number;
+    visible?: boolean;
 }
+
+/**
+ * Interaction surface — selection, highlighting and the camera.
+ *
+ * The types a host exchanges with the viewer at runtime rather than at
+ * configuration time: what is addressed (`ModuleRef`, `MoverRef`), what is
+ * picked out (`SelectionState`, `ModuleHighlight`, `FeedSegmentHighlight`),
+ * and where the camera looks (`CameraState`, `FocusTarget`).
+ */
+
 interface ModuleRef {
     processingUnitObjectId: number;
     partObjectId: number;
@@ -1183,125 +974,412 @@ interface FeedSegmentHighlight {
     color: string;
 }
 /**
- * One feed segment (Einspeisestrang) as detected in the configuration: the
- * contiguous run of modules starting at an infeed module (Einspeisemodul,
- * `ModuleCatalogEntry.isInfeed`) and ending right before the next infeed
- * module of the same part.
- *
- * On a closed chain (oval, U-turn pair — see `isChainClosed`) the modules
- * ahead of the part's first infeed module belong to the LAST segment, which
- * then carries `wrapsSeam: true`. On an open chain those leading modules
- * belong to no segment at all and cannot be tinted.
- *
- * Returned by `XtsViewer3DRef.getFeedSegments()`.
+ * One feed segment (Einspeisestrang) as detected in the configuration: the
+ * contiguous run of modules starting at an infeed module (Einspeisemodul,
+ * `ModuleCatalogEntry.isInfeed`) and ending right before the next infeed
+ * module of the same part.
+ *
+ * On a closed chain (oval, U-turn pair — see `isChainClosed`) the modules
+ * ahead of the part's first infeed module belong to the LAST segment, which
+ * then carries `wrapsSeam: true`. On an open chain those leading modules
+ * belong to no segment at all and cannot be tinted.
+ *
+ * Returned by `XtsViewer3DRef.getFeedSegments()`.
+ */
+interface FeedSegment {
+    processingUnitObjectId: number;
+    partObjectId: number;
+    /** 0-based, in chain order, counted from the part's first infeed module. */
+    segmentIndex: number;
+    /**
+     * `ModuleEntry.globalNumber` of the leading infeed module. `undefined` when
+     * the config does not set it — such a segment can only be addressed via
+     * `{ partObjectId, segmentIndex }`.
+     */
+    infeedModuleGlobalNumber?: number;
+    /** Module type of the leading infeed module. */
+    infeedModuleType: ModuleType3D;
+    /** Chain indices of every module in this segment, in chain order. */
+    moduleIndices: number[];
+    /** Σ of the segment's module lengths, in mm. */
+    lengthMm: number;
+    /** True when the segment wraps the closed-loop seam. */
+    wrapsSeam: boolean;
+}
+interface CameraState {
+    positionMm: Vec3;
+    targetMm: Vec3;
+    /** Always 'Z' in the current spec. */
+    upAxis: 'Z' | 'Y';
+    zoom?: number;
+}
+/**
+ * Live camera projection.
+ *   - `'perspective'` (default) — the regular 3D view.
+ *   - `'orthographic'` — paired with `topDown`, gives the flat 2D plan view
+ *     that matches `exportScreenshot({ mode: 'top-down' })`.
+ */
+type CameraProjection = 'perspective' | 'orthographic';
+/**
+ * Target for the imperative `viewerRef.current.focusOn(target, opts)` camera
+ * animation. The viewer computes the target's world-space bounding box and
+ * flies the camera so the whole object fits the frame:
+ *   - In `'perspective'` projection the current view angle is preserved
+ *     (the camera only dollies / re-centres).
+ *   - In `'orthographic'` top-down the frustum is re-framed and the camera
+ *     pans straight over the object.
+ */
+type FocusTarget = {
+    kind: 'scene';
+} | {
+    kind: 'station';
+    stationId: number;
+} | {
+    kind: 'area';
+    areaId: number;
+} | {
+    kind: 'mover';
+    ref: MoverRef;
+} | {
+    kind: 'module';
+    ref: ModuleRef;
+};
+interface FocusOptions {
+    /** Animation duration in ms. Default 700. `0` jumps immediately. */
+    durationMs?: number;
+    /**
+     * Padding around the target's bounding box (1 = tight fit). Default 1.2 in
+     * perspective, 1.1 in orthographic top-down.
+     */
+    paddingFactor?: number;
+    /** Easing curve. Default `'easeInOutCubic'`. */
+    easing?: 'linear' | 'easeInOutCubic';
+}
+
+/**
+ * Viewer errors.
+ *
+ * `XtsViewerErrorException` is the one runtime value in the public type
+ * surface — everything else the viewer exports as `types` is erased at
+ * compile time. It is thrown by the normalization pass for configurations
+ * that cannot be rendered at all; recoverable problems are reported through
+ * the `onError` callback as plain `XtsViewerError` records instead.
+ */
+type XtsViewerErrorCode = 'asset-load-failed' | 'unknown-module-type' | 'unknown-mover-type' | 'unknown-tool-type' | 'invalid-config' | 'unmatched-clothoid-half' | 'webgl-context-lost';
+interface XtsViewerError {
+    code: XtsViewerErrorCode;
+    message: string;
+    details?: unknown;
+}
+declare class XtsViewerErrorException extends Error {
+    readonly code: XtsViewerErrorCode;
+    readonly details?: unknown;
+    constructor(code: XtsViewerErrorCode, message: string, details?: unknown);
+}
+
+/**
+ * Asset manifest — per-type overrides for the GLB URLs the viewer loads.
+ *
+ * A host registers custom or relocated assets here instead of replacing the
+ * whole `assetsBaseUrl`. Entries fall back to the default CDN mapping for any
+ * type they do not name.
+ */
+
+interface AssetManifest {
+    /** Override per moduleType. Falls back to default mapping otherwise. */
+    modules?: Partial<Record<ModuleType3D, ModuleAssetEntry>>;
+    movers?: Partial<Record<MoverType3D, MoverAssetEntry>>;
+    tools?: Partial<Record<MoverToolType3D, MoverToolAssetEntry>>;
+    guidingRails?: Partial<Record<RailType3D, RailAssetEntry>>;
+}
+interface RailAssetEntry {
+    glbUrl: string;
+    sidecarUrl?: string;
+}
+interface ModuleAssetEntry {
+    /** Per-RailSystem GLB URL (relative to assetsBaseUrl). */
+    glbByRailSystem: {
+        Beckhoff: string | null;
+        HepcoGfx?: string | null;
+    };
+    sidecarUrl?: string;
+}
+interface MoverAssetEntry {
+    glbUrl: string;
+    sidecarUrl?: string;
+}
+interface MoverToolAssetEntry {
+    glbUrl: string;
+    sidecarUrl?: string;
+}
+
+/**
+ * Public types for the measurement + annotation feature.
+ *
+ * Everything here is expressed in the viewer's WORLD frame — millimetres,
+ * Z-up, identical to `XtsViewer3DRef.getMoverWorldTransform()` and
+ * `CameraState.positionMm`. That is what makes one implementation serve both
+ * the perspective 3D view and the orthographic 2D plan view
+ * (`projection='orthographic'`): only the camera differs, the geometry does
+ * not.
+ */
+
+/**
+ * How a measurement point was derived. `'free'` is the raw ray hit (surface
+ * or ground plane); everything else is a snap the picker resolved to.
+ */
+type SnapKind = 'free' | 'vertex' | 'edge-midpoint' | 'face-center' | 'grid' | 'mover-center' | 'module-boundary' | 'module-center' | 'station-stop' | 'track-path';
+/** Scene entity a picked point belongs to, when the picker could resolve one. */
+type MeasuredEntityRef = {
+    kind: 'module';
+    ref: ModuleRef;
+} | {
+    kind: 'mover';
+    ref: MoverRef;
+} | {
+    kind: 'station';
+    stationId: number;
+};
+/** A position on a part's track path, in the XPU's user position frame. */
+interface TrackAnchor {
+    processingUnitObjectId: number;
+    /** `PartConfig.objectId`. */
+    partObjectId: number;
+    /** Position along the part, user frame (same convention as movers). */
+    partPositionMm: number;
+}
+/** One measurement vertex. */
+interface MeasurementPoint {
+    /** World position (mm). */
+    positionMm: Vec3;
+    /** How the point was obtained. Default `'free'` when omitted. */
+    snap?: SnapKind;
+    /** Entity the point sits on, when known. */
+    entity?: MeasuredEntityRef;
+    /**
+     * Track position, set whenever the point resolved onto a part's path.
+     * Required on both endpoints of a `'trackDistance'` measurement.
+     */
+    track?: TrackAnchor;
+}
+/** Snapping configuration. */
+interface SnapOptions {
+    /** Master switch. Default `true`. */
+    enabled?: boolean;
+    /**
+     * Snap kinds to consider, highest priority first. Default:
+     * `['vertex', 'edge-midpoint', 'mover-center', 'module-boundary',
+     *   'station-stop', 'track-path', 'face-center']`.
+     */
+    kinds?: SnapKind[];
+    /** Screen-space radius (px) a candidate must fall within. Default `14`. */
+    radiusPx?: number;
+    /**
+     * Grid step (mm) for the `'grid'` snap, applied to the free hit point when
+     * no other candidate matched and `'grid'` is in `kinds`. Default `0` (off).
+     */
+    gridMm?: number;
+}
+type MeasurementId = string;
+type MeasurementKind = 'distance' | 'angle' | 'path' | 'trackDistance';
+/** Axis constraint for a distance measurement. */
+type MeasurementAxis = 'free' | 'x' | 'y' | 'z';
+interface MeasurementBase {
+    id: MeasurementId;
+    /** Optional caption rendered above the value. */
+    label?: string;
+    /** Overrides `MeasurementStyle.color` for this one measurement. */
+    color?: string;
+    /** Default `true`. */
+    visible?: boolean;
+    /** Free-form payload the host can round-trip (never read by the viewer). */
+    meta?: Record<string, unknown>;
+}
+/** Straight-line distance between two points. */
+interface DistanceMeasurement extends MeasurementBase {
+    kind: 'distance';
+    points: [MeasurementPoint, MeasurementPoint];
+    /** Constrain the reported value to one axis. Default `'free'`. */
+    axis?: MeasurementAxis;
+    /** Render dashed ΔX / ΔY / ΔZ guides. Default `false`. */
+    showComponents?: boolean;
+}
+/** Angle at `points[1]` between the legs to `points[0]` and `points[2]`. */
+interface AngleMeasurement extends MeasurementBase {
+    kind: 'angle';
+    /** `[legA, vertex, legB]` — the middle point is the vertex. */
+    points: [MeasurementPoint, MeasurementPoint, MeasurementPoint];
+}
+/** Polyline through N points; reports per-segment and total length. */
+interface PathMeasurement extends MeasurementBase {
+    kind: 'path';
+    points: MeasurementPoint[];
+    /** Close the polyline back to the first point. Default `false`. */
+    closed?: boolean;
+    /** Label every segment, not just the total. Default `true`. */
+    showSegmentLengths?: boolean;
+}
+/**
+ * Distance ALONG the XTS track between two points on the same part — the
+ * distance a mover actually travels, not the straight line.
  */
-interface FeedSegment {
-    processingUnitObjectId: number;
-    partObjectId: number;
-    /** 0-based, in chain order, counted from the part's first infeed module. */
-    segmentIndex: number;
+interface TrackDistanceMeasurement extends MeasurementBase {
+    kind: 'trackDistance';
+    points: [MeasurementPoint, MeasurementPoint];
+}
+type Measurement = DistanceMeasurement | AngleMeasurement | PathMeasurement | TrackDistanceMeasurement;
+/** Same as `Measurement`, but the store generates the `id` when omitted. */
+type MeasurementInput = (Omit<DistanceMeasurement, 'id'> & {
+    id?: MeasurementId;
+}) | (Omit<AngleMeasurement, 'id'> & {
+    id?: MeasurementId;
+}) | (Omit<PathMeasurement, 'id'> & {
+    id?: MeasurementId;
+}) | (Omit<TrackDistanceMeasurement, 'id'> & {
+    id?: MeasurementId;
+});
+/** Computed value of a measurement. */
+interface MeasurementResult {
+    id: MeasurementId;
+    kind: MeasurementKind;
+    /** Millimetres for lengths, degrees for angles. */
+    value: number;
+    unit: 'mm' | 'deg';
+    /** Formatted value as rendered in the scene (e.g. `'1 234.5 mm'`). */
+    text: string;
+    /** Signed component deltas — `'distance'` only. */
+    deltaMm?: Vec3;
+    /** Per-segment lengths — `'path'` only. */
+    segmentLengthsMm?: number[];
     /**
-     * `ModuleEntry.globalNumber` of the leading infeed module. `undefined` when
-     * the config does not set it — such a segment can only be addressed via
-     * `{ partObjectId, segmentIndex }`.
+     * `true` when the measurement could not be evaluated (e.g. a
+     * `trackDistance` whose endpoints sit on different parts). `value` is then
+     * the straight-line fallback.
      */
-    infeedModuleGlobalNumber?: number;
-    /** Module type of the leading infeed module. */
-    infeedModuleType: ModuleType3D;
-    /** Chain indices of every module in this segment, in chain order. */
-    moduleIndices: number[];
-    /** Σ of the segment's module lengths, in mm. */
-    lengthMm: number;
-    /** True when the segment wraps the closed-loop seam. */
-    wrapsSeam: boolean;
+    incomplete?: boolean;
 }
-interface CameraState {
+/** Where an annotation hangs. Mover anchors follow the live mover position. */
+type AnnotationAnchor = {
+    kind: 'world';
     positionMm: Vec3;
-    targetMm: Vec3;
-    /** Always 'Z' in the current spec. */
-    upAxis: 'Z' | 'Y';
-    zoom?: number;
-}
-/**
- * Live camera projection.
- *   - `'perspective'` (default) — the regular 3D view.
- *   - `'orthographic'` — paired with `topDown`, gives the flat 2D plan view
- *     that matches `exportScreenshot({ mode: 'top-down' })`.
- */
-type CameraProjection = 'perspective' | 'orthographic';
-/**
- * Target for the imperative `viewerRef.current.focusOn(target, opts)` camera
- * animation. The viewer computes the target's world-space bounding box and
- * flies the camera so the whole object fits the frame:
- *   - In `'perspective'` projection the current view angle is preserved
- *     (the camera only dollies / re-centres).
- *   - In `'orthographic'` top-down the frustum is re-framed and the camera
- *     pans straight over the object.
- */
-type FocusTarget = {
-    kind: 'scene';
-} | {
-    kind: 'station';
-    stationId: number;
-} | {
-    kind: 'area';
-    areaId: number;
 } | {
     kind: 'mover';
     ref: MoverRef;
 } | {
     kind: 'module';
     ref: ModuleRef;
-};
-interface FocusOptions {
-    /** Animation duration in ms. Default 700. `0` jumps immediately. */
-    durationMs?: number;
+} | ({
+    kind: 'trackPosition';
+} & TrackAnchor);
+interface Annotation {
+    id: string;
+    text: string;
+    anchor: AnnotationAnchor;
     /**
-     * Padding around the target's bounding box (1 = tight fit). Default 1.2 in
-     * perspective, 1.1 in orthographic top-down.
+     * Leader-line offset from the anchor to the label (mm, world frame).
+     * Default `[0, 0, 250]`.
      */
-    paddingFactor?: number;
-    /** Easing curve. Default `'easeInOutCubic'`. */
-    easing?: 'linear' | 'easeInOutCubic';
-}
-type XtsViewerErrorCode = 'asset-load-failed' | 'unknown-module-type' | 'unknown-mover-type' | 'unknown-tool-type' | 'invalid-config' | 'unmatched-clothoid-half' | 'webgl-context-lost';
-interface XtsViewerError {
-    code: XtsViewerErrorCode;
-    message: string;
-    details?: unknown;
-}
-declare class XtsViewerErrorException extends Error {
-    readonly code: XtsViewerErrorCode;
-    readonly details?: unknown;
-    constructor(code: XtsViewerErrorCode, message: string, details?: unknown);
-}
-interface AssetManifest {
-    /** Override per moduleType. Falls back to default mapping otherwise. */
-    modules?: Partial<Record<ModuleType3D, ModuleAssetEntry>>;
-    movers?: Partial<Record<MoverType3D, MoverAssetEntry>>;
-    tools?: Partial<Record<MoverToolType3D, MoverToolAssetEntry>>;
-    guidingRails?: Partial<Record<RailType3D, RailAssetEntry>>;
+    offsetMm?: Vec3;
+    color?: string;
+    /** Text height (mm). Default `MeasurementStyle.labelSizeMm`. */
+    sizeMm?: number;
+    /** Marker drawn at the anchor. Default `'Sphere'`. */
+    markerShape?: MarkerShape;
+    markerSizeMm?: number;
+    /** Default `true`. */
+    visible?: boolean;
+    meta?: Record<string, unknown>;
 }
-interface RailAssetEntry {
-    glbUrl: string;
-    sidecarUrl?: string;
+type AnnotationInput = Omit<Annotation, 'id'> & {
+    id?: string;
+};
+type MeasurementTool = 'none' | 'distance' | 'angle' | 'path' | 'trackDistance' | 'annotation';
+/** In-progress pick. `null` while no tool is armed. */
+interface MeasurementDraft {
+    tool: Exclude<MeasurementTool, 'none'>;
+    /** Points committed so far. */
+    points: MeasurementPoint[];
+    /** Point currently under the cursor, or `null` when off the scene. */
+    hover: MeasurementPoint | null;
 }
-interface ModuleAssetEntry {
-    /** Per-RailSystem GLB URL (relative to assetsBaseUrl). */
-    glbByRailSystem: {
-        Beckhoff: string | null;
-        HepcoGfx?: string | null;
-    };
-    sidecarUrl?: string;
+interface MeasurementStyle {
+    /** Line + label colour of committed measurements. Default `'#00E5FF'`. */
+    color?: string;
+    /** Colour of the in-progress draft. Default `'#FFC400'`. */
+    draftColor?: string;
+    /** Annotation colour. Default `'#FFFFFF'`. */
+    annotationColor?: string;
+    /** Line width in pixels. Default `2`. */
+    lineWidthPx?: number;
+    /** Text height (mm). Default `40`. */
+    labelSizeMm?: number;
+    /** Endpoint marker diameter (mm). Default `18`. */
+    pointSizeMm?: number;
+    /** Decimal places on values. Default `1`. */
+    decimals?: number;
+    /** Unit suffix appended to lengths. Default `' mm'`. */
+    unitSuffix?: string;
+    /** Font URL passed to troika (see `DEFAULT_LABEL_FONT_URL`). */
+    fontFamily?: string;
+    /**
+     * Draw measurement lines and markers through solid geometry
+     * (`depthTest: false`). Default `true` — CAD viewers keep dimensions
+     * readable regardless of what is in front of them.
+     */
+    alwaysOnTop?: boolean;
 }
-interface MoverAssetEntry {
-    glbUrl: string;
-    sidecarUrl?: string;
+/** Serializable snapshot of everything the measurement feature holds. */
+interface MeasurementDocument {
+    schemaVersion: 1;
+    measurements: Measurement[];
+    annotations: Annotation[];
 }
-interface MoverToolAssetEntry {
-    glbUrl: string;
-    sidecarUrl?: string;
+/**
+ * `measurement` prop of `<XtsViewer3D>`. Data can be driven either
+ * declaratively (`measurements` / `annotations` — controlled arrays) or
+ * imperatively via `viewerRef.current.measurements`. When the controlled
+ * arrays are supplied they win on every render, so a host that uses them must
+ * persist what the change callbacks report.
+ */
+interface MeasurementOptions {
+    /** Armed tool. Default `'none'` — no picking, no cursor change. */
+    tool?: MeasurementTool;
+    /** Controlled measurement list. Omit to let the viewer keep its own. */
+    measurements?: MeasurementInput[];
+    /** Controlled annotation list. Omit to let the viewer keep its own. */
+    annotations?: AnnotationInput[];
+    snap?: SnapOptions;
+    style?: MeasurementStyle;
+    /**
+     * Z of the fallback pick plane (mm) used when the ray misses all geometry,
+     * so free space can be measured. Default `0`; `null` disables the fallback.
+     */
+    groundPlaneZMm?: number | null;
+    /** Fired after every change to the measurement list. */
+    onMeasurementsChange?: (measurements: Measurement[], results: MeasurementResult[]) => void;
+    /** Fired once when a tool completes a measurement. */
+    onMeasurementCreate?: (measurement: Measurement, result: MeasurementResult) => void;
+    onAnnotationsChange?: (annotations: Annotation[]) => void;
+    onAnnotationCreate?: (annotation: Annotation) => void;
+    /** Fired on every draft change (point added, hover moved, cancelled). */
+    onDraftChange?: (draft: MeasurementDraft | null) => void;
+    /**
+     * Text for an annotation the `'annotation'` tool just placed. Return
+     * `null` to abort. Default: `'Annotation'`.
+     */
+    annotationTextFactory?: (point: MeasurementPoint) => string | null;
 }
+
+/**
+ * `XtsModelDocument` — the canonical serialized form of a viewer scene.
+ *
+ * What `viewerRef.current.exportModel()` produces and what a host persists:
+ * the configuration, optionally the runtime mover state, and optionally the
+ * measurements. The measurement half keeps its own types next to its
+ * implementation (`measurement/types.ts`); only the serialized document
+ * surfaces here.
+ */
+
 interface XtsModelDocument {
     schemaVersion: 1;
     meta: {
@@ -2524,12 +2602,13 @@ declare class SidecarLoader {
     private readonly timeoutMs;
     private readonly cache;
     constructor(timeoutMs?: number);
-    fetchModule(url: string): Promise<ModuleSidecar | undefined>;
-    fetchMover(url: string): Promise<MoverSidecar | undefined>;
-    fetchTool(url: string): Promise<MoverToolSidecar | undefined>;
-    fetchRail(url: string): Promise<RailSidecar | undefined>;
     clear(): void;
-    private fetchJson;
+    /**
+     * Fetch and cache the sidecar at `url`. The loader validates the one field
+     * every sidecar shape shares (`originCorrection`) and hands the rest to the
+     * caller as `T` — the kind is a property of the URL, not of the loader.
+     */
+    fetch<T>(url: string): Promise<T | undefined>;
 }
 /**
  * Resolve the effective origin correction for a module sidecar — falls back
@@ -3615,6 +3694,54 @@ declare function getSharedAssetLoader(): AssetLoader;
 /** Compose a URL from a base + a filename, normalising trailing slashes. */
 declare function composeAssetUrl(baseUrl: string, filename: string): string;
 
+/**
+ * The four sidecar kinds as data.
+ *
+ * Modules, movers, tools and rails all resolve their calibration the same
+ * way — compiled-in table, else `<assetsBaseUrl>/<filename>`, else identity.
+ * Only two things differ per kind: which built-in table to read and how the
+ * filename is spelled. Keeping those two as a table (rather than four copies
+ * of the resolution logic) means `useSidecar` and the calibration tool share
+ * one implementation and a new kind is one entry, not one more branch.
+ *
+ * `filename` returning `null` marks an id that has no sidecar at all — the
+ * `'Custom'` mover / tool, whose layout comes from the config instead. That
+ * keeps "no lookup for Custom" a data fact rather than a special case each
+ * consumer has to remember.
+ */
+
+/** Id and sidecar shape carried by each kind. */
+interface SidecarKinds {
+    module: {
+        id: ModuleType3D;
+        sidecar: ModuleSidecar;
+    };
+    mover: {
+        id: MoverType3D;
+        sidecar: MoverSidecar;
+    };
+    tool: {
+        id: MoverToolType3D;
+        sidecar: MoverToolSidecar;
+    };
+    rail: {
+        id: RailType3D;
+        sidecar: RailSidecar;
+    };
+}
+type SidecarKind = keyof SidecarKinds;
+type SidecarIdOf<K extends SidecarKind> = SidecarKinds[K]['id'];
+type SidecarOf<K extends SidecarKind> = SidecarKinds[K]['sidecar'];
+interface SidecarKindSpec<K extends SidecarKind> {
+    /** Sidecar filename for `id`, or `null` when the id carries no sidecar. */
+    filename(id: SidecarIdOf<K>): string | null;
+    /** Compiled-in sidecar for `id`, if the bundle carries one. */
+    builtin(id: SidecarIdOf<K>): SidecarOf<K> | undefined;
+}
+declare const SIDECAR_KINDS: {
+    [K in SidecarKind]: SidecarKindSpec<K>;
+};
+
 /**
  * Style resolution for the measurement overlay — one place where every
  * default lives, so the scene, the draft preview and the value formatting
@@ -3716,4 +3843,4 @@ declare function snapToGrid(positionMm: Vec3, gridMm: number): Vec3;
 /** Convenience: `resolveSceneContext` + `toEntityRef`. */
 declare function resolveEntityFromObject(object: Object3D | null, instanceId?: number): MeasuredEntityRef | null;
 
-export { type AngleMeasurement, type Annotation, type AnnotationAnchor, type AnnotationInput, type AreaConfig, type AreaOptions, AssetLoader, type AssetManifest, BUILTIN_MODULE_SIDECARS, BUILTIN_MOVER_SIDECARS, BUILTIN_RAIL_SIDECARS, BUILTIN_TOOL_SIDECARS, type BuiltChain, type BuiltModule, type CameraProjection, type CameraState, type CaptureMode, type CheckModuleCollisionsOptions, type CheckMoverCollisionsOptions, type ClickModifiers, type CoordinateSystem, type CustomAssetBinding, type CustomAssetConfig, type CustomMoverLayout, DEFAULT_LABEL_FONT_URL, DEFAULT_MEASUREMENT_STYLE, DEFAULT_MODULE_HALF_WIDTH_MM, DEFAULT_MODULE_HEIGHT_MM, DEFAULT_MODULE_MANIFEST, DEFAULT_MOVER_MANIFEST, DEFAULT_ORIGIN_CORRECTION, DEFAULT_RAIL_MANIFEST, DEFAULT_SNAP_KINDS, DEFAULT_SNAP_RADIUS_PX, DEFAULT_TOOL_MANIFEST, type DimensionOptions, type DisplayOptions, type DistanceMeasurement, EMPTY_SELECTION, type EndDelta, type FeedSegment, type FeedSegmentHighlight, type FeedSegmentSelector, type FeedSegmentSpan, type FocusOptions, type FocusTarget, type FrameCaptureOptions, type FrameCaptureSession, HEPCO_GFX_PROFILE, type HeatmapSample, type HepcoGfxRailProfileDims, IDENTITY_POSE, INFEED_MODULE_TYPES, type InfoBarConfig, type InfoBarMarkerConfig, type InfoBarOptions, JSDELIVR_ASSETS_BASE_URL, MODULE_CATALOG, MODULE_GUIDING_RAIL_MAP, MOVER_CATALOG, type MarkerOptions, type MarkerShape, type MeasuredEntityRef, type Measurement, type MeasurementApi, type MeasurementAxis, type MeasurementDocument, type MeasurementDraft, type MeasurementFormatOptions, type MeasurementId, type MeasurementInput, type MeasurementKind, type MeasurementOptions, type MeasurementPoint, type MeasurementResult, type MeasurementSnapshot, type MeasurementStyle, type MeasurementTool, type ModuleAssetEntry, type ModuleCatalogEntry, type ModuleCollision, type ModuleCollisionPartInput, type ModuleCollisionXpuInput, ModuleCornerMarkers, type ModuleEntry, type ModuleHighlight, type ModuleProbe, type ModuleRef, type ModuleSidecar, type ModuleStatusEntry, type ModuleType3D, type MoverAssetEntry, type MoverCatalogEntry, type MoverCollision, type MoverConfig, MoverIdLabel, type MoverIdLabelOptions, type MoverPositionEntry, type MoverProbe, type MoverRef, type MoverSidecar, type MoverToolAssetEntry, type MoverToolConfig, type MoverToolSidecar, type MoverToolType3D, type MoverType3D, type NormalizationWarning, type NormalizedXtsConfig, type Orientation, type OriginCorrection, type PartConfig, type PartPath, type PartTransformation, type PathMeasurement, type PathSample, type PathType, type PlanarPose, type PointCloud, type PointProjector, type PositionFrame, type ProcessingUnitConfig, type RailAssetEntry, type RailSidecar, type RailSystem, type RailType3D, type ResolvedMeasurementStyle, type ScreenshotFormat, type ScreenshotMode, type ScreenshotOptions, type ScreenshotResult, type SelectionMode, type SelectionState, SidecarLoader, type SidecarOverrides, type SidecarSourceConfig, SidecarSourceContext, type SnapCandidate, type SnapKind, type SnapOptions, type SplitFeedSegmentsOptions, type StationConfig, type StationOptions, type StatorHeatmap, type StopPositionMoverOptions, type TextOptions, type TrackAnchor, type TrackDistanceMeasurement, type TrackIndex, type TrackIndexEntry, type TrackMetrics, type TrackMetricsResolver, type TrackProjection, type TrackTransform, VERSION, type Vec2, type Vec3, XtsArcCurve3, type XtsConfig, XtsConfigNormalizer, type XtsModelDocument, XtsPointCloudCurve3, type XtsRuntimeState, XtsViewer3D, type XtsViewer3DProps, type XtsViewer3DRef, type XtsViewerError, type XtsViewerErrorCode, XtsViewerErrorException, angleDeg, applyBeckhoffXtsConvention, applyEmptyClick, applyModuleClick, applyMoverClick, arcPoints, axisDistanceMm, buildChain, buildModuleProbes, buildPartPath, buildTrackIndex, chainToUserPositionMm, checkModuleCollisions, checkSamePathCollisions, chooseSnapCandidate, collectFeedSegments, collectFeedSegmentsForXpu, collectTriangleSnapCandidates, composeAssetUrl, computeMeasurementResult, createHepcoGfxBaseplateShape, createHepcoGfxRailShape, deselectAll, distanceMm, findModuleAt, formatAngleDeg, formatLengthMm, getModuleEntry, getMoverEntry, getPointCloud, getSharedAssetLoader, interpolateHeatmapValue, isChainClosed, isKnownModuleType, isKnownMoverType, isModuleSelected, isMoverSelected, labelAnchorFor, moduleAnchorWorld, moduleEndDelta, moduleSidecarFilename, moverAnchorWorld, moverSidecarFilename, moverWorldAt, nearestTrackPoint, normaliseToHeatmapRange, normalizeXtsConfig, pathLengthsMm, pickGlbForRail, poseToMatrix4, railSidecarFilename, registerPointCloud, resolveEntityFromObject, resolveGuidingRailGlbUrl, resolveGuidingRailType, resolveHepcoGfxProfile, resolveMeasurementStyle, resolveModuleGlbUrl, resolveMoverGlbUrl, resolveOriginCorrection, resolveStopPositionMm, resolveToolGlbUrl, sampleChainPoint, sampleChainRange, sampleModulePath, snapToGrid, sortHeatmapSamples, splitIntoFeedSegments, toolSidecarFilename, trackAnchorWorld, trackDistanceMm, trackLengthOf, trackPolylineWorld, unregisterPointCloud, useSidecarSource, userToChainPositionMm, worldPointOnPart };
+export { type AngleMeasurement, type Annotation, type AnnotationAnchor, type AnnotationInput, type AreaConfig, type AreaOptions, AssetLoader, type AssetManifest, BUILTIN_MODULE_SIDECARS, BUILTIN_MOVER_SIDECARS, BUILTIN_RAIL_SIDECARS, BUILTIN_TOOL_SIDECARS, type BuiltChain, type BuiltModule, type CameraProjection, type CameraState, type CaptureMode, type CheckModuleCollisionsOptions, type CheckMoverCollisionsOptions, type ClickModifiers, type CoordinateSystem, type CustomAssetBinding, type CustomAssetConfig, type CustomMoverLayout, DEFAULT_LABEL_FONT_URL, DEFAULT_MEASUREMENT_STYLE, DEFAULT_MODULE_HALF_WIDTH_MM, DEFAULT_MODULE_HEIGHT_MM, DEFAULT_MODULE_MANIFEST, DEFAULT_MOVER_MANIFEST, DEFAULT_ORIGIN_CORRECTION, DEFAULT_RAIL_MANIFEST, DEFAULT_SNAP_KINDS, DEFAULT_SNAP_RADIUS_PX, DEFAULT_TOOL_MANIFEST, type DimensionOptions, type DisplayOptions, type DistanceMeasurement, EMPTY_SELECTION, type EndDelta, type FeedSegment, type FeedSegmentHighlight, type FeedSegmentSelector, type FeedSegmentSpan, type FocusOptions, type FocusTarget, type FrameCaptureOptions, type FrameCaptureSession, HEPCO_GFX_PROFILE, type HeatmapSample, type HepcoGfxRailProfileDims, IDENTITY_POSE, INFEED_MODULE_TYPES, type InfoBarConfig, type InfoBarMarkerConfig, type InfoBarOptions, JSDELIVR_ASSETS_BASE_URL, MODULE_CATALOG, MODULE_GUIDING_RAIL_MAP, MOVER_CATALOG, type MarkerOptions, type MarkerShape, type MeasuredEntityRef, type Measurement, type MeasurementApi, type MeasurementAxis, type MeasurementDocument, type MeasurementDraft, type MeasurementFormatOptions, type MeasurementId, type MeasurementInput, type MeasurementKind, type MeasurementOptions, type MeasurementPoint, type MeasurementResult, type MeasurementSnapshot, type MeasurementStyle, type MeasurementTool, type ModuleAssetEntry, type ModuleCatalogEntry, type ModuleCollision, type ModuleCollisionPartInput, type ModuleCollisionXpuInput, ModuleCornerMarkers, type ModuleEntry, type ModuleHighlight, type ModuleProbe, type ModuleRef, type ModuleSidecar, type ModuleStatusEntry, type ModuleType3D, type MoverAssetEntry, type MoverCatalogEntry, type MoverCollision, type MoverConfig, MoverIdLabel, type MoverIdLabelOptions, type MoverPositionEntry, type MoverProbe, type MoverRef, type MoverSidecar, type MoverToolAssetEntry, type MoverToolConfig, type MoverToolSidecar, type MoverToolType3D, type MoverType3D, type NormalizationWarning, type NormalizedXtsConfig, type Orientation, type OriginCorrection, type PartConfig, type PartPath, type PartTransformation, type PathMeasurement, type PathSample, type PathType, type PlanarPose, type PointCloud, type PointProjector, type PositionFrame, type ProcessingUnitConfig, type RailAssetEntry, type RailSidecar, type RailSystem, type RailType3D, type ResolvedMeasurementStyle, SIDECAR_KINDS, type ScreenshotFormat, type ScreenshotMode, type ScreenshotOptions, type ScreenshotResult, type SelectionMode, type SelectionState, type SidecarIdOf, type SidecarKind, type SidecarKindSpec, type SidecarKinds, SidecarLoader, type SidecarOf, type SidecarOverrides, type SidecarSourceConfig, SidecarSourceContext, type SnapCandidate, type SnapKind, type SnapOptions, type SplitFeedSegmentsOptions, type StationConfig, type StationOptions, type StatorHeatmap, type StopPositionMoverOptions, type TextOptions, type TrackAnchor, type TrackDistanceMeasurement, type TrackIndex, type TrackIndexEntry, type TrackMetrics, type TrackMetricsResolver, type TrackProjection, type TrackTransform, VERSION, type Vec2, type Vec3, XtsArcCurve3, type XtsConfig, XtsConfigNormalizer, type XtsModelDocument, XtsPointCloudCurve3, type XtsRuntimeState, XtsViewer3D, type XtsViewer3DProps, type XtsViewer3DRef, type XtsViewerError, type XtsViewerErrorCode, XtsViewerErrorException, angleDeg, applyBeckhoffXtsConvention, applyEmptyClick, applyModuleClick, applyMoverClick, arcPoints, axisDistanceMm, buildChain, buildModuleProbes, buildPartPath, buildTrackIndex, chainToUserPositionMm, checkModuleCollisions, checkSamePathCollisions, chooseSnapCandidate, collectFeedSegments, collectFeedSegmentsForXpu, collectTriangleSnapCandidates, composeAssetUrl, computeMeasurementResult, createHepcoGfxBaseplateShape, createHepcoGfxRailShape, deselectAll, distanceMm, findModuleAt, formatAngleDeg, formatLengthMm, getModuleEntry, getMoverEntry, getPointCloud, getSharedAssetLoader, interpolateHeatmapValue, isChainClosed, isKnownModuleType, isKnownMoverType, isModuleSelected, isMoverSelected, labelAnchorFor, moduleAnchorWorld, moduleEndDelta, moduleSidecarFilename, moverAnchorWorld, moverSidecarFilename, moverWorldAt, nearestTrackPoint, normaliseToHeatmapRange, normalizeXtsConfig, pathLengthsMm, pickGlbForRail, poseToMatrix4, railSidecarFilename, registerPointCloud, resolveEntityFromObject, resolveGuidingRailGlbUrl, resolveGuidingRailType, resolveHepcoGfxProfile, resolveMeasurementStyle, resolveModuleGlbUrl, resolveMoverGlbUrl, resolveOriginCorrection, resolveStopPositionMm, resolveToolGlbUrl, sampleChainPoint, sampleChainRange, sampleModulePath, snapToGrid, sortHeatmapSamples, splitIntoFeedSegments, toolSidecarFilename, trackAnchorWorld, trackDistanceMm, trackLengthOf, trackPolylineWorld, unregisterPointCloud, useSidecarSource, userToChainPositionMm, worldPointOnPart };