@konitif/viewer-3d 0.284.1

package/dist/renderer/Viewer3DRenderer.d.ts

@@ -0,0 +1,1137 @@
+import type { ViewerJointHandleDefinition, ViewerSupportDefinition, ViewerDiagnosticContactDefinition, ViewerBalanceFootprintDefinition, ViewerHandTipDefinition, ViewerLedRingCalibration, ViewerLedReferenceFrame, ViewerLedPlacementDefinition } from '../index.js';
+import { type TemporalSchedulerHost } from '@konitif/temporal';
+import type { BodyTransform, JointTarget, PhysicsEngineType, PhysicsRuntimeConfig, PhysicsServiceSnapshot, PhysicsServicePort, RobotPhysicsSource } from '@konitif/physics';
+import { type ViewerMetadata } from './ViewerMetadata.js';
+import type { ViewerHistoryPort, ViewerHistoryObservation } from './ViewerHistoryPort.js';
+import type { ViewerHistorySample } from './ViewerHistoryData.js';
+export type ViewerRuntimeHistoryPort = ViewerHistoryPort<Omit<ViewerHistorySample<ViewerMetadata>, 'id' | 'recordedAt'> & {
+    recordedAt?: number;
+}, ViewerHistoryObservation<ViewerHistorySample<ViewerMetadata>>>;
+import { type InteractionInputBinding, type InteractionInputBindingOverride, type InteractionInputSignal } from '@konitif/tools/input';
+import { Object3D, OrthographicCamera, PerspectiveCamera, Quaternion, Scene, Vector3, WebGLRenderer } from 'three';
+import { ArcballControls } from 'three/examples/jsm/controls/ArcballControls.js';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { type RobotMotionAnimation } from './robotViewerMotion.js';
+import { type Viewer3DNavigationPhysicsObservation } from './NavigationPhysicsObservation.js';
+import { type ViewerIncarnationHealth } from './ViewerIncarnationHealth.js';
+import { type Viewer3DPerformanceSummary } from './PerformanceMonitor.js';
+import { type ViewerTemporalProjectionMode, type ViewerTemporalProjectionStatus } from './TemporalProjectionModel.js';
+import { type ObservedRobotPresentationStatus } from './ObservedRobotPresentationBuffer.js';
+import type { ViewerExperimentCollector } from './ViewerExperimentCollector.js';
+import type { ViewerExperimentPort, ViewerExperimentStart } from './ViewerExperimentPort.js';
+import { type RobotSagittalPostureCompensationOptions } from './RobotPostureCompensation.js';
+import { type ViewerPlaybackCompletionBehavior } from './ViewerPlaybackCompletionPolicy.js';
+import { type ObservedRobotGroundingProjection, type ObservedRobotSupportInclinationProjection } from './ObservedRobotGroundingProjection.js';
+import { type ViewerVisualGroundComponentId, type ViewerVisualGroundOptions, type ViewerVisualGroundPaletteOptions } from './VisualGroundLayer.js';
+export declare const VIEWER3D_PROJECTILE_PARTICLE_LIMIT = 24;
+export declare function resolveViewerFocusTiltBlurStrength(framingSpan: number): number;
+export declare function resolveViewerPoseHandleDistanceOpacity(subjectScreenSpanPixels: number): number;
+export declare function resolveViewerCameraClippingPlanes(input: {
+    requestedNear: number;
+    requestedFar: number;
+    groundSize: number;
+    maximumCameraDistance?: number;
+}): {
+    near: number;
+    far: number;
+};
+export interface ViewerNavigationPresentationFrame {
+    position: Vector3;
+    quaternion: Quaternion;
+}
+/** Maps the local MoveTo frame (+Z forward, +X left) onto one robot incarnation. */
+export declare function resolveViewerNavigationPresentationFrame(input: {
+    activePosition: Vector3;
+    activeOrientation: Quaternion;
+    referenceOrientation: Quaternion;
+}): ViewerNavigationPresentationFrame;
+export declare function projectViewerNavigationWorldPointToLocal(point: Vector3, frame: ViewerNavigationPresentationFrame): Vector3;
+export type RobotViewerVector = {
+    x: number;
+    y: number;
+    z: number;
+};
+export type RobotViewerQuaternion = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+export interface Viewer3DPhysicsObservation {
+    sampleId: string;
+    observedAtMs: number;
+    simulatedTimeSeconds: number;
+    centerOfMass: BodyTransform['position'] | null;
+    bodyTransforms: readonly BodyTransform[];
+    navigation: Viewer3DNavigationPhysicsObservation | null;
+}
+export interface Viewer3DRobotComparisonAppearance {
+    mode: 'overlay' | 'offset' | 'observed-only';
+    centeredSeparation: boolean;
+    offsetMeters: number;
+    observed: {
+        opacity: number;
+        tint: string;
+    };
+    simulated: {
+        opacity: number;
+        tint: string;
+    };
+}
+export interface Viewer3DPoseHandleDefinition {
+    readonly id: string;
+    readonly label: string;
+    readonly names: readonly string[];
+    readonly color: string;
+}
+export interface Viewer3DOptions<Artifact = unknown, Snapshot = unknown> {
+    /** Visibility host only: frame scheduling remains owned by the viewer's AnimationLoop. */
+    temporalSchedulerHost?: TemporalSchedulerHost;
+    supportDefinition?: ViewerSupportDefinition;
+    diagnosticContactDefinitions?: readonly ViewerDiagnosticContactDefinition[];
+    balanceFootprintDefinitions?: readonly ViewerBalanceFootprintDefinition[];
+    /** Ordered model anchors; absent/unresolved names use the geometric center. */
+    cameraFocusAnchorNames?: readonly string[];
+    projectileTargetAnchorNames?: readonly string[];
+    /** Pure presentation policy; undefined selects the neutral renderer color. */
+    resolveJointColor?: (jointId: string) => string | undefined;
+    /** Pure model policy; absent means no implicit joint trajectory selection. */
+    shouldRenderJointTrajectory?: (jointId: string, jointType?: string) => boolean;
+    handTipDefinitions?: readonly ViewerHandTipDefinition[];
+    ledRingDefaults?: Readonly<Record<string, Readonly<Viewer3DLedRingCalibration>>>;
+    headLedFrame?: ViewerLedReferenceFrame | null;
+    bodyLedPlacements?: Readonly<Record<string, readonly ViewerLedPlacementDefinition[]>>;
+    jointHandleDefinitions?: readonly ViewerJointHandleDefinition[];
+    /** Product-supplied visual anchors. No implicit model-specific handles. */
+    poseHandleDefinitions?: readonly Viewer3DPoseHandleDefinition[];
+    transparent?: boolean;
+    showRobot?: boolean;
+    showObservedRobotGhost?: boolean;
+    groundObservedRobotGhost?: boolean;
+    showAxes?: boolean;
+    showGrid?: boolean;
+    showVisualGround?: boolean;
+    visualGround?: ViewerVisualGroundOptions;
+    visualGroundPalette?: ViewerVisualGroundPaletteOptions;
+    showStats?: boolean;
+    showGlobalRafProbe?: boolean;
+    showTrajectories?: boolean;
+    showHandTrajectoriesOnly?: boolean;
+    showContactPoints?: boolean;
+    showPhysicsDebug?: boolean;
+    showPhysicsColliders?: boolean;
+    showPhysicsCenterOfMass?: boolean;
+    showPhysicsGravity?: boolean;
+    showEyeRingDebug?: boolean;
+    showEyeRingMire?: boolean;
+    eyeRingCalibration?: Partial<Viewer3DEyeRingCalibration>;
+    showBalanceDebug?: boolean;
+    showPoseHandles?: boolean;
+    poseHandleOcclusion?: boolean;
+    interactionMode?: Viewer3DInteractionMode;
+    inputBindings?: readonly InteractionInputBinding[];
+    inputBindingOverrides?: readonly InteractionInputBindingOverride[];
+    cameraProjection?: Viewer3DCameraProjection;
+    cameraControlMode?: Viewer3DCameraControlMode;
+    antialias?: boolean;
+    antialiasMode?: 'none' | 'msaa' | 'fxaa' | 'smaa';
+    maxPixelRatio?: number;
+    minPixelRatio?: number;
+    adaptivePixelRatio?: boolean;
+    targetFrameRate?: number;
+    autonomousPlayback?: boolean;
+    continuousPlaybackRender?: boolean;
+    stopPlaybackAtRangeEnd?: boolean;
+    transitionToAnimationStart?: boolean;
+    controlsEnabled?: boolean;
+    suspendWhenViewportHidden?: boolean;
+    physicsEngine?: PhysicsEngineType;
+    physicsEnabled?: boolean;
+    physicsMotorsCoupled?: boolean;
+    physicsStepRateHz?: number;
+    physicsPostureCompensation?: RobotSagittalPostureCompensationOptions | null;
+    physicsService: PhysicsServicePort;
+    /** Injected services are caller-owned by default. Use 'viewer' to transfer disposal responsibility.
+     * This does not coordinate shared simulation writes.
+     */
+    physicsServiceOwnership?: 'caller' | 'viewer';
+    runtimeHistory?: ViewerRuntimeHistoryPort | null;
+    runtimeHistorySampleIntervalMs?: number;
+    /** Dedicated collector configured for the temporal projection protocol. Omit for legacy collection. */
+    temporalProjectionExperimentCollector: ViewerExperimentCollector<Artifact, Snapshot>;
+    temporalProjectionMode?: ViewerTemporalProjectionMode;
+    temporalProjectionBufferDelayMs?: number;
+    temporalProjectionMaxSampleGapMs?: number;
+    physicsObservationEnabled?: boolean;
+    onTemporalProjectionStatus?: (status: ViewerTemporalProjectionStatus) => void;
+    onPhysicsObservation?: (observation: Viewer3DPhysicsObservation) => void;
+    onCameraInteractionStart?: () => void;
+    cameraPosition?: RobotViewerVector;
+    cameraTarget?: RobotViewerVector;
+    onNavigationDestination?: (destination: RobotViewerVector) => void;
+    onNavigationSimulationObservation?: (observation: Viewer3DNavigationSimulationObservation) => void;
+    onProjectileInteraction?: (observation: Viewer3DProjectileInteractionObservation) => void;
+}
+export interface Viewer3DNavigationMoveToParameters {
+    forwardDistanceM: number;
+    leftDistanceM: number;
+    leftAngularDistanceRad: number;
+}
+export interface Viewer3DNavigationSimulationObservation extends Viewer3DNavigationMoveToParameters {
+    provenance: 'kinematic-preview';
+    progress: number;
+    completed: boolean;
+}
+export type Viewer3DInteractionMode = 'projectile' | 'camera' | 'joint' | 'pose' | 'navigate';
+export type Viewer3DCameraProjection = 'perspective' | 'iso';
+export type Viewer3DCameraControlMode = 'orbit' | 'arcball';
+export type Viewer3DSymmetricCameraView = 'mixed' | 'left' | 'right';
+export type Viewer3DPhysicalEntryMode = 'grounded-reset' | 'stabilized-continuation';
+export interface Viewer3DProjectileInteractionObservation {
+    status: 'idle' | 'charging' | 'launched' | 'impact' | 'ground-contact' | 'settled' | 'removed' | 'rejected';
+    target: Viewer3DPoseControlTarget;
+    massKilograms: number;
+    speedMetersPerSecond: number;
+    activeCount: number;
+    limit: number;
+    launchedCount: number;
+    chargeRatio: number;
+    reason?: 'real-capability-unavailable' | 'physics-unavailable' | 'target-unavailable' | 'projectile-limit-reached';
+}
+export type Viewer3DLedRingZoneId = 'eyes' | 'headTop' | 'ears' | 'hands' | 'feet' | 'torso';
+export type Viewer3DLedRingCalibration = ViewerLedRingCalibration;
+export interface Viewer3DEyeRingCalibration extends Viewer3DLedRingCalibration {
+    zones?: Partial<Record<Viewer3DLedRingZoneId, Partial<Viewer3DLedRingCalibration>>>;
+}
+export interface Viewer3DPlaybackState {
+    sourceId?: string | null;
+    /** Stable identity of the authored subject projected by this occurrence. */
+    subjectId?: string | null;
+    /** Complete projected duration, including non-motion content such as audio. */
+    durationSeconds?: number | null;
+    currentTime: number;
+    resolveAuthoritativeCurrentTime?: (() => number) | null;
+    resolveTemporalProjectionSample?: ((currentTimeSeconds: number) => ViewerHistorySample<ViewerMetadata> | null) | null;
+    /** `manual` delegates time advancement to the deterministic buffer producer. */
+    clockMode?: 'realtime' | 'manual';
+    /** Independent playback reset, or continuation from a preceding stabilized clip. */
+    physicalEntryMode?: Viewer3DPhysicalEntryMode;
+    isPlaying?: boolean;
+    playbackRate?: number;
+    loopPlayback?: boolean;
+    workRange?: {
+        start: number;
+        end: number;
+    };
+    mutedTrackTargets?: readonly string[];
+    completionBehavior?: ViewerPlaybackCompletionBehavior;
+    completionReached?: boolean;
+    completionTransitionDurationMs?: number;
+    startTransitionMinimumDurationSeconds?: number;
+    entryPose?: Readonly<Record<string, number>> | 'robot-default' | null;
+    endTransitionMinimumDurationSeconds?: number;
+    exitPose?: Readonly<Record<string, number>> | 'robot-default' | null;
+    completionTargetPose?: Readonly<Record<string, number>> | null;
+}
+export interface Viewer3DPoseEditDetail {
+    dirty: boolean;
+    jointIds: string[];
+    jointValues: Record<string, number>;
+    action: 'change' | 'apply' | 'revert' | 'reset';
+}
+export type Viewer3DPoseControlTarget = 'simulated' | 'observed';
+export interface Viewer3DObservedRobotVisibilityOptions {
+    transitionCameraFocus?: boolean;
+    transitionPresentation?: boolean;
+    nextPoseControlTarget?: Viewer3DPoseControlTarget;
+    durationMs?: number;
+}
+export interface Viewer3DJointHoverDetail {
+    jointIds: string[];
+    activeJointIds?: string[];
+    phase?: 'hover' | 'select' | 'drag' | 'clear';
+}
+export interface Viewer3DLivePoseTargetDetail {
+    phase: 'start' | 'change' | 'end';
+    targets: Array<{
+        jointId: string;
+        positionRad: number;
+    }>;
+}
+interface Viewer3DDestroyOptions {
+    reason?: 'dispose' | 'hmr';
+}
+type ViewerArcballControls = ArcballControls & {
+    readonly target: Vector3;
+};
+type ViewerCameraControls = OrbitControls | ViewerArcballControls;
+export declare class Viewer3D<Artifact = unknown, Snapshot = unknown> implements ViewerExperimentPort<Artifact, Snapshot> {
+    readonly container: HTMLDivElement;
+    readonly renderer: WebGLRenderer;
+    readonly scene: Scene;
+    readonly perspectiveCamera: PerspectiveCamera;
+    readonly orthographicCamera: OrthographicCamera;
+    camera: PerspectiveCamera | OrthographicCamera;
+    controls: ViewerCameraControls;
+    readonly resizeObserver: ResizeObserver;
+    private composer;
+    private renderPass;
+    private horizontalTiltShiftPass;
+    private verticalTiltShiftPass;
+    private postProcessingAntialiasPass;
+    private robot;
+    private readonly simulatedRobotPresentationRoot;
+    private readonly observedRobotPresentationRoot;
+    private observedRobotGhost;
+    private observedRobotGhostMirrorsSimulatedRobot;
+    private comparisonProfileId;
+    private comparisonViewerSample;
+    private readonly comparisonColliderGroup;
+    private readonly comparisonColliders;
+    private comparisonCenterOfMassMarker;
+    private poseControlTarget;
+    private observedPoseLiveControlEnabled;
+    private readonly robotMaterialBaselines;
+    private readonly observedRobotGhostMaterialBaselines;
+    private readonly observedRobotGhostRenderOrderBaselines;
+    private readonly observedRobotGhostShadowMaterials;
+    private observedRobotGhostShadowOpacity;
+    private robotComparisonVisibilityTransition;
+    private cameraTransitionActive;
+    private readonly observedRobotGhostBasePosition;
+    private readonly observedRobotGhostBaseQuaternion;
+    private observedRobotTemporalSupportAnchorState;
+    private observedRobotGrounding;
+    private observedRobotSupportInclination;
+    private robotComparisonAppearance;
+    private axesHelper;
+    private gridHelper;
+    private visualGroundLayer;
+    private keyLight;
+    private trajectoryGroup;
+    private contactPointGroup;
+    private physicsDebugGroup;
+    private physicsDebugGroundMesh;
+    private physicsDebugGravityArrow;
+    private eyeRingDebugGroup;
+    private balanceDebugGroup;
+    private balanceDebugCenterOfMassQualified;
+    private balanceDebugCenterOfMassFadeStartedAt;
+    private simulatedRobotInitializationOffsetStartedAt;
+    private simulatedRobotInitializationOffsetFromY;
+    private poseHandleGroup;
+    private navigationPreviewGroup;
+    private navigationMarker;
+    private navigationPath;
+    private navigationMarkerAnimationStartedAt;
+    private navigationSimulationCursor;
+    private navigationSimulationPoints;
+    private navigationSimulationStartedAt;
+    private navigationSimulationDurationMs;
+    private navigationSimulationTargetYawRad;
+    private navigationSimulationResolve;
+    private navigationSimulationPhysicsBaseline;
+    private projectileInteractionGroup;
+    private projectileLauncherGroup;
+    private projectileSlingshotLeftElastic;
+    private projectileSlingshotRightElastic;
+    private projectileSlingshotPouch;
+    private projectileSlingshotLoadedBall;
+    private projectileSlingshotPullRatio;
+    private projectileSlingshotReleaseState;
+    private projectileTrajectoryLine;
+    private projectileTrajectoryLaunchOverlay;
+    private projectileImpactArrow;
+    private projectileParticleRenderer;
+    private projectileAimLaunch;
+    private readonly projectileAimTarget;
+    private projectileAimSpeedMetersPerSecond;
+    private projectileChargeStartedAt;
+    private projectileLastChargeRatio;
+    private projectileAimTransition;
+    private readonly projectileParticles;
+    private nextProjectileParticleId;
+    private projectilePhysicsSettlingUntil;
+    private readonly projectileRaycaster;
+    private readonly projectilePointer;
+    private projectilePointerInside;
+    private trajectoryAnimation;
+    private trajectorySignature;
+    private trajectoryAnchors;
+    private themeObserver;
+    private animationLoop;
+    private defaultPose;
+    private defaultRobotTransform;
+    private physicsResetPose;
+    private physicsResetRobotTransform;
+    private physicsResetBaselineCaptureFrames;
+    private physicsResetBaselineCaptureFrameCount;
+    private physicsPostureCompensationTransitionFrameActive;
+    private lastAnimatedJointTargets;
+    private nextAnimatedJointTargets;
+    private readonly transientDesiredProjectionValues;
+    private readonly transientDesiredProjectionBaseline;
+    private playbackState;
+    private playbackTransitionState;
+    private playbackCompletionTransitionState;
+    private boundaryPosePreviewTransitionState;
+    private deferredBoundaryPreviewRuntimeHistoryProjection;
+    private scrubPreviewState;
+    private lastScrubPhysicsSyncAt;
+    private playbackSyncSignature;
+    private physicsKinematicHoldFrames;
+    private physicsKinematicHoldRootPose;
+    private physicsProjectionMinimumStateRevision;
+    private statsCadenceElement;
+    private statsCadenceTextElement;
+    private statsGraphCanvas;
+    private readonly performanceMonitor;
+    private readonly temporalProjection;
+    private readonly observedRobotPresentation;
+    private readonly temporalProjectionExperiment;
+    private viewportObserver;
+    private resizeFrame;
+    private resizeSettleTimer;
+    private transientInvisibleResizePasses;
+    private currentPixelRatio;
+    private averageFrameMs;
+    private averageRafFrameMs;
+    private averageGlobalRafFrameMs;
+    private readonly configuredTargetFrameRate;
+    private observedFrameRateCeiling;
+    private lastRafAt;
+    private lastGlobalRafAt;
+    private lastCadenceReportAt;
+    private rafFramesSinceReport;
+    private globalRafFramesSinceReport;
+    private renderFramesSinceReport;
+    private playbackFramesSinceReport;
+    private scrubFramesSinceReport;
+    private lastFrameAt;
+    private lastPixelRatioTuneAt;
+    private averageLoopMs;
+    private averagePoseMs;
+    private averageControlsMs;
+    private averageRenderMs;
+    private lastRenderCalls;
+    private lastRenderTriangles;
+    private longTaskObserver;
+    private longTaskCountSinceReport;
+    private longTaskDurationSinceReport;
+    private globalRafProbeFrame;
+    private profilerTimerProbe;
+    private lastProfilerTimerProbeAt;
+    private averageProfilerTimerDelayMs;
+    private viewportVisible;
+    private rendererClientWidth;
+    private rendererClientHeight;
+    private rendererPixelRatio;
+    private orthographicViewHeight;
+    private controlsActive;
+    private controlsSettlingFrames;
+    private visualGroundReflectionInteractionActive;
+    private destroyed;
+    private readonly selectionController;
+    private lastDispatchedJointHoverSignature;
+    private poseHandleDragState;
+    private poseHandleTargetTransitionState;
+    private poseHandleDragStarted;
+    private poseHandleControlsWereEnabled;
+    private suppressPoseHandleClickUntil;
+    private poseEditBaseline;
+    private dirtyPose;
+    private readonly dirtyPoseJointIds;
+    private readonly physicsDebugMarkers;
+    private readonly physicsDebugLinks;
+    private readonly physicsDebugColliders;
+    private physicsCenterOfMassMarker;
+    private readonly temporalInvalidation;
+    private readonly temporalScheduler;
+    private readonly physicsService;
+    private cameraController;
+    private readonly poseHandleRaycaster;
+    private readonly poseHandlePointer;
+    private readonly navigationRaycaster;
+    private readonly navigationPointer;
+    private readonly navigationGroundPlane;
+    private readonly visualGroundFocusProjection;
+    private readonly poseHandleLocalAnchorOffsets;
+    private readonly options;
+    private resolvedInputBindings;
+    private readonly cameraPoseLocked;
+    private lastPhysicsStepAt;
+    private readonly physicsAuthoredJointTargets;
+    private physicsPostureCompensationTiltRadians;
+    private physicsAuxiliaryJointNames;
+    private physicsVisualRootBodyName;
+    private physicsVisualRootToRobotMatrix;
+    private physicsJointMappings;
+    private physicsVisualBodyObjectNames;
+    private physicsVisualAlignmentProfile;
+    private lastRuntimeHistorySampleAt;
+    private unsubscribeRuntimeHistory;
+    private lastRuntimeHistoryReplaySignature;
+    private runtimeHistoryReplayActive;
+    private runtimeHistoryProjectionRequiresPhysicsRebase;
+    private runtimeHistoryProjectedPhysicsRootPose;
+    private isApplyingRuntimeHistorySample;
+    private isApplyingPhysicsPose;
+    private temporalProjectionDiscontinuitySequence;
+    private lastTemporalProjectionSampleId;
+    private lastTemporalProjectionStatusSignature;
+    private projectedPhysicsBodyTransforms;
+    private projectedPhysicsCenterOfMass;
+    private get hoveredPoseHandleId();
+    private set hoveredPoseHandleId(value);
+    private get hoveredPoseHandleAxisId();
+    private set hoveredPoseHandleAxisId(value);
+    private get hoveredPoseHandleAxisIds();
+    private set hoveredPoseHandleAxisIds(value);
+    private get externalHoveredJointTargets();
+    private set externalHoveredJointTargets(value);
+    private get selectedPoseHandleId();
+    private set selectedPoseHandleId(value);
+    private get selectedPoseHandleAxisId();
+    private set selectedPoseHandleAxisId(value);
+    private get selectedPoseHandleAxisIds();
+    private set selectedPoseHandleAxisIds(value);
+    private get needsRender();
+    private set needsRender(value);
+    private get wasContinuousLoopActive();
+    private set wasContinuousLoopActive(value);
+    constructor(container: HTMLDivElement, options: Viewer3DOptions<Artifact, Snapshot>);
+    setStatsVisible(showStats: boolean): void;
+    setGlobalRafProbeVisible(showGlobalRafProbe: boolean): void;
+    setGridVisible(showGrid: boolean): void;
+    setVisualGroundVisible(showVisualGround: boolean): void;
+    configureVisualGround(config: ViewerVisualGroundOptions, palette?: ViewerVisualGroundPaletteOptions): void;
+    setVisualGroundComponentVisible(componentId: ViewerVisualGroundComponentId, visible: boolean): void;
+    setAxesVisible(showAxes: boolean): void;
+    setOrientationGizmoVisible(_showOrientationGizmo: boolean): void;
+    setRobotVisible(showRobot: boolean): void;
+    /**
+     * Installs a second visual incarnation reserved for observed robot telemetry.
+     * It never participates in physics, authoring, selection, or command routing.
+     */
+    setObservedRobotGhost(robot: Object3D | null): void;
+    /**
+     * Makes the secondary incarnation a read-only profile comparison projection.
+     * Canonical joint values are copied from the simulated robot at render time;
+     * the secondary robot never becomes an authoring or physics authority.
+     */
+    setObservedRobotGhostMirrorsSimulatedRobot(enabled: boolean): void;
+    setObservedRobotGhostIndependentSimulation(profileId: string | null): void;
+    private projectComparisonSimulation;
+    setObservedRobotGhostVisible(visible: boolean, options?: Viewer3DObservedRobotVisibilityOptions): void;
+    projectObservedRobotGhostJointValues(values: Readonly<Record<string, number | null>>): boolean;
+    /**
+     * Admits one immutable observed pose into the visual-only smoothing buffer.
+     * The upstream frame remains the sole telemetry authority; reconstructed
+     * values are applied only to the observed ghost incarnation.
+     */
+    ingestObservedRobotGhostJointObservation(input: {
+        frameId: string;
+        connectionId: string;
+        observedAtSeconds: number | null;
+        jointValues: Readonly<Record<string, number>>;
+        receivedAtMs?: number;
+    }): boolean;
+    resetObservedRobotGhostJointObservation(): void;
+    getObservedRobotPresentationStatus(): ObservedRobotPresentationStatus;
+    private applyObservedRobotGhostJointValues;
+    private updateObservedRobotGhostPresentation;
+    getObservedRobotGroundingProjection(): ObservedRobotGroundingProjection;
+    getObservedRobotSupportInclinationProjection(): ObservedRobotSupportInclinationProjection;
+    /**
+     * Changes only the comparison projection. Simulation state and observed
+     * telemetry remain untouched and continue to be owned by their sources.
+     */
+    setRobotComparisonAppearance(appearance: Viewer3DRobotComparisonAppearance): void;
+    setPhysicsEngine(physicsEngine: PhysicsEngineType, physicsEnabled?: boolean): Promise<void>;
+    setPhysicsEnabled(physicsEnabled: boolean): void;
+    setPhysicsObservationEnabled(enabled: boolean): void;
+    setPhysicsMotorsCoupled(physicsMotorsCoupled: boolean): void;
+    setTransitionToAnimationStart(enabled: boolean): void;
+    loadPhysicsRobot(source: RobotPhysicsSource): Promise<void>;
+    resetPhysicsSimulation(): Promise<void>;
+    getPhysicsSnapshot(): PhysicsServiceSnapshot;
+    readNavigationPhysicsObservation(): Viewer3DNavigationPhysicsObservation | null;
+    getPerformanceSummary(): Viewer3DPerformanceSummary;
+    setTemporalProjectionMode(mode: ViewerTemporalProjectionMode): void;
+    getTemporalProjectionStatus(): ViewerTemporalProjectionStatus;
+    getIncarnationHealth(): ViewerIncarnationHealth;
+    startTemporalProjectionExperiment(input: ViewerExperimentStart): Snapshot;
+    markTemporalProjectionExperimentPhase(phaseId: string, observedAtMs: number, provenance?: ViewerMetadata): boolean;
+    stopTemporalProjectionExperiment(endedAtMs: number): Artifact;
+    getTemporalProjectionExperimentSnapshot(): Snapshot;
+    releasePhysicsJointTargets(targets?: Record<string, JointTarget>): void;
+    clearPhysicsJointTargets(): void;
+    setPhysicsRuntimeConfig(config: PhysicsRuntimeConfig): void;
+    setPhysicsResetBaselineCaptureFrames(frameCount: number): void;
+    inspectRuntimeHistorySnapshot(snapshot: ViewerHistoryObservation<ViewerHistorySample<ViewerMetadata>>): void;
+    projectRuntimeHistorySample(sample: ViewerHistorySample<ViewerMetadata>, options?: {
+        applyCamera?: boolean;
+        deferDuringBoundaryPosePreview?: boolean;
+    }): void;
+    captureRuntimeHistoryProjectionSample(options?: {
+        timeSeconds?: number;
+    }): void;
+    /**
+     * Advances the isolated producer by an explicit simulation slice. This is a
+     * bake operation: no RAF, audio clock or visible playback transport can own
+     * the temporal cursor while it runs.
+     */
+    bakeRuntimeHistoryProjectionFrame(input: {
+        currentTimeSeconds: number;
+        deltaSeconds: number;
+        recordTimeSeconds: number;
+        record?: boolean;
+        kinematicBoundary?: 'entry' | 'exit' | null;
+    }): Promise<boolean>;
+    resumeRuntimeHistoryLiveProjection(): void;
+    resumeRuntimeHistoryBufferedProjection(): void;
+    setTrajectoriesVisible(showTrajectories: boolean): void;
+    setHandTrajectoriesOnly(showHandTrajectoriesOnly: boolean): void;
+    setInteractionMode(interactionMode: Viewer3DInteractionMode): void;
+    setNavigationPreview(input: {
+        destination: RobotViewerVector;
+        points: readonly RobotViewerVector[];
+        moveTo: Viewer3DNavigationMoveToParameters;
+    } | null): void;
+    playNavigationSimulation(points: readonly RobotViewerVector[], leftAngularDistanceRad?: number): Promise<'completed' | 'cancelled' | 'unavailable'>;
+    cancelNavigationSimulation(): void;
+    setExternalHoveredJointTargets(jointTargets: readonly string[]): void;
+    setPoseHandlesVisible(showPoseHandles: boolean): void;
+    setPoseHandleOcclusionEnabled(enabled: boolean): void;
+    /**
+     * Chooses the incarnation used to place pose controls. The observed target
+     * remains telemetry-only; selecting it never mutates its joint values.
+     */
+    setPoseControlTarget(target: Viewer3DPoseControlTarget, options?: {
+        transitionCameraFocus?: boolean;
+        durationMs?: number;
+        comparisonVisibilityAppearing?: boolean;
+    }): void;
+    /** Emits desired targets from observed-anchored handles without mutating telemetry. */
+    setObservedPoseLiveControlEnabled(enabled: boolean): void;
+    setContactPointsVisible(showContactPoints: boolean): void;
+    setPhysicsDebugVisible(showPhysicsDebug: boolean): void;
+    setPhysicsCollidersVisible(showPhysicsColliders: boolean): void;
+    setPhysicsCenterOfMassVisible(showPhysicsCenterOfMass: boolean): void;
+    setPhysicsGravityVisible(showPhysicsGravity: boolean): void;
+    setEyeRingDebugVisible(showEyeRingDebug: boolean): void;
+    setEyeRingMireVisible(showEyeRingMire: boolean): void;
+    setEyeRingCalibration(eyeRingCalibration: Partial<Viewer3DEyeRingCalibration>): void;
+    setBalanceDebugVisible(showBalanceDebug: boolean): void;
+    setTrajectoryPreview(animation: RobotMotionAnimation | null): void;
+    setRobot(robot: Object3D): void;
+    getRobot(): Object3D | null;
+    private syncRobotPoseAfterRobotLoad;
+    markProfilerSignal(label: string): void;
+    applyPoseEdit(): void;
+    revertPoseEdit(): void;
+    applyAnimationFrame(animation: RobotMotionAnimation | null, time: number, mutedTrackTargets?: readonly string[]): void;
+    /**
+     * Projects temporary desired joint values directly on the visible robot.
+     * This is a read-only authoring projection: it does not mutate the authored
+     * animation, advance physics, or promote the displayed frame into runtime.
+     */
+    projectDesiredJointValues(values: Readonly<Record<string, number | null>>): boolean;
+    /**
+     * Projects an owner-scoped desired pose without authoring, physics or runtime effects.
+     * The baseline is retained so removing one projection restores the visual pose that
+     * existed before that owner became active.
+     */
+    setTransientDesiredJointProjection(ownerId: string, values: Readonly<Record<string, number | null>>): boolean;
+    clearTransientDesiredJointProjection(ownerId: string): boolean;
+    syncScrubPreview(animation: RobotMotionAnimation | null, time: number, mutedTrackTargets?: readonly string[], active?: boolean): void;
+    syncAnimationPlayback(animation: RobotMotionAnimation | null, playback: Viewer3DPlaybackState): void;
+    previewBoundaryPose(pose: Readonly<Record<string, number>> | 'robot-default', durationMs?: number): boolean;
+    private getPlaybackSyncSignature;
+    private createPoseSignature;
+    private createMutedTrackTargetSet;
+    private createMutedTrackTargetSignature;
+    private resolveMutedTrackTargetSet;
+    private applyRobotPose;
+    private updateScrubPreviewPose;
+    private hasPendingScrubPreviewWork;
+    private resolveAnimationTransitionStartTime;
+    private ensureAnimationStartTransition;
+    private createAnimationStartTransition;
+    private resolveImmediateAnimationStartTransitionEndTime;
+    private updatePlaybackStartTransition;
+    private resolveTrackFirstKeyAtOrAfter;
+    private updatePlaybackEndTransition;
+    private resolveTrackLastKeyAtOrBefore;
+    private updatePlaybackPose;
+    private startPlaybackCompletionTransition;
+    private updatePlaybackCompletionTransition;
+    private updateBoundaryPosePreviewTransition;
+    frameRobotToView(): void;
+    destroy(options?: Viewer3DDestroyOptions): void;
+    private setupScene;
+    private ensureAxesHelper;
+    private ensureGridHelper;
+    private ensureVisualGroundLayer;
+    private updateVisualGroundEnvironment;
+    private updateVisualGroundShadowCasters;
+    private setupStats;
+    private teardownStats;
+    private observeThemeChanges;
+    private readThemeColor;
+    private applyTheme;
+    private resolveVisualGroundPalette;
+    private resolveVisualGroundSkyColor;
+    private resolveGridPalette;
+    private applyGridVertexColors;
+    private resolveThemeColor;
+    private toThreeColorValue;
+    private getColorLuminance;
+    private createRenderer;
+    private getViewportAspect;
+    private resolveOrthographicViewHeightFromPerspectiveDistance;
+    private updateCameraProjectionForViewport;
+    private createCameraControls;
+    private setControlsCamera;
+    private setCameraControlsMotionEnabled;
+    private disposeCameraControls;
+    private applyCameraPose;
+    private applyCameraPlanes;
+    private syncPostProcessingCamera;
+    private getMaximumPixelRatio;
+    private getMinimumPixelRatio;
+    private readViewportAuthority;
+    private applyRendererSize;
+    private setupPostProcessing;
+    private updateVisualGroundFocusTiltPasses;
+    private updateVisualGroundFocusTiltStrength;
+    private updateVisualGroundFocusTarget;
+    private tunePixelRatio;
+    private observeViewportVisibility;
+    private handleResize;
+    private scheduleResize;
+    private scheduleSettledResize;
+    private cancelResizeSettleTimer;
+    private cancelResizeWork;
+    private flushResize;
+    private loop;
+    private render;
+    private renderResizeFrame;
+    private hasContinuousRenderWork;
+    private isPhysicsActive;
+    private applyPhysicsPostureCompensation;
+    private resetPhysicsPostureCompensation;
+    private stepPhysics;
+    private capturePhysicsVisualJointAngles;
+    private syncRobotPoseFromProjectedJointAngles;
+    private resetTemporalProjection;
+    private resolveTemporalProjectionDiscontinuityToken;
+    private publishTemporalProjectionStatus;
+    private recordRuntimeHistorySample;
+    private serializeRuntimeHistoryTransform;
+    private subscribeRuntimeHistory;
+    private applyRuntimeHistorySample;
+    private captureRuntimeHistoryVisualJointStates;
+    private applyRuntimeHistoryVisualJointStates;
+    private reconcileRecordedMimicJoints;
+    private applyRuntimeHistoryJointStates;
+    private resolveRuntimeHistoryPhysicsRootPose;
+    private deserializeRuntimeHistoryTransform;
+    private requestRender;
+    private scheduleLoop;
+    private updateRafCadence;
+    private startGlobalRafProbe;
+    private runGlobalRafProbe;
+    private resetStatsCadence;
+    private getEffectiveTargetFrameRate;
+    private getTargetFrameRate;
+    private updateStatsCadence;
+    private recordProfilerSample;
+    private getProfilerDocumentState;
+    private formatPlaybackProfilerState;
+    private formatProfilerSignals;
+    private markFrameSignal;
+    private consumeToolPerformanceProbeSummary;
+    private startProfilerTimerProbe;
+    private stopProfilerTimerProbe;
+    private drawStatsHistoryGraph;
+    private drawStatsGraphGrid;
+    private drawStatsGraphSeries;
+    private getProfilerFpsCeiling;
+    private getProfilerMsCeiling;
+    private observeMainThreadLongTasks;
+    private updateProfilerAverage;
+    private getProfilerHotPhase;
+    private formatCompactCount;
+    private disposeObject3D;
+    private configureObservedRobotGhostMaterials;
+    private applyObservedRobotGhostRenderOrder;
+    private applyObservedRobotGhostShadowOpacity;
+    private clearObservedRobotGhost;
+    private applyRobotComparisonAppearance;
+    private applyObservedRobotGhostGrounding;
+    private resolveObservedRobotSupportContacts;
+    private resolveObservedRobotSupportContactPoints;
+    private selectObservedRobotSupportPoints;
+    private resolveObservedRobotSupport;
+    private resolveFiniteBoundsMinimumY;
+    private resolveObservedRobotBodyEnvelopeBounds;
+    private resolveObservedRobotCollisionBounds;
+    private resolveObservedRobotRenderedBounds;
+    private resolveObservedRobotMeshBounds;
+    private resolveRobotFootSupportBounds;
+    private groundSimulatedRobotOnSupportFloor;
+    private resolveRobotSupportBounds;
+    private resolveRobotSupportGeometryBounds;
+    private captureMaterialBaselines;
+    private captureMaterialBaseline;
+    private readComparisonOpacityFactor;
+    private applyComparisonOpacityFactor;
+    private startRobotComparisonVisibilityTransition;
+    private updateRobotComparisonVisibilityTransition;
+    private cancelRobotComparisonVisibilityTransition;
+    private applyMaterialAppearance;
+    private disposeMaterial;
+    private resolveRobotObject;
+    private resolveObjectFromRobot;
+    private getPoseControlRobot;
+    private resolvePoseControlObject;
+    private resolveRobotCameraFocusFrame;
+    /**
+     * Camera presets are authored in the normalized simulated-robot frame. Map
+     * their world-space offset into the selected incarnation without applying
+     * the model normalization twice. This keeps the existing visual directions
+     * for SIM while allowing REAL yaw/orientation to drive the same preset.
+     */
+    private resolvePoseControlCameraOffset;
+    private getPoseControlJoints;
+    private getRobotJoints;
+    private syncObservedRobotGhostFromSimulatedRobot;
+    private setJointValue;
+    private applyAuthoredJointValue;
+    /**
+     * Applies a transient desired pose to the visual incarnation only.
+     *
+     * Timeline authoring is a reader/manipulator of the authored projection, not
+     * a physics command. Routing this value through setJointValue() or
+     * applyAuthoredJointValue() would update the coupled physics target and defer
+     * the visible result until the simulator publishes another observation.
+     */
+    private applyDesiredProjectionJointValue;
+    private syncPhysicsJointTarget;
+    private syncPhysicsJointTargetsFromRobotPose;
+    private createPhysicsJointTargetsFromRobotPose;
+    private createPhysicsJointTargetsFromAuthoredTargets;
+    private syncPhysicsKinematicPoseFromRobotPose;
+    private syncPhysicsKinematicPoseFromAuthoredTargets;
+    /**
+     * Materializes an unbuffered timeline pose as a grounded initial condition.
+     *
+     * Buffered temporal samples already own their recorded root/physics state
+     * and must never pass through this path. For live authored playback, the
+     * visual support and the physics support are aligned atomically so the first
+     * simulation step cannot inherit a stale, airborne root transform.
+     */
+    private alignUnbufferedPlaybackPoseToSupportFloor;
+    private syncPhysicsKinematicPoseTargets;
+    private rememberPhysicsAuthoredJointTargets;
+    private schedulePhysicsResetBaselineCapture;
+    private updatePhysicsResetBaselineCapture;
+    private capturePhysicsResetBaseline;
+    private canCapturePhysicsResetBaseline;
+    private shouldSyncPhysicsKinematicPose;
+    private syncRobotPoseFromPhysicsJointStates;
+    private syncRobotRootFromPhysicsBody;
+    private beginSimulatedRobotInitializationPresentation;
+    private updateSimulatedRobotInitializationPresentation;
+    private resolvePhysicsStateRevision;
+    private acceptFreshPhysicsRootProjection;
+    private resolvePhysicsVisualRootToRobotMatrix;
+    private getPhysicsRootCalibrationScore;
+    private createPhysicsBodyViewerWorldMatrix;
+    private createPhysicsCoordinateFrameMatrix;
+    private createPhysicsCoordinateFrameQuaternion;
+    private resolvePhysicsSceneYawRadians;
+    private shouldSyncPhysicsJointTargets;
+    private resolvePhysicsJointMapping;
+    private getDirectPhysicsJointMappings;
+    private readJointValue;
+    private resolveJointValueRatio;
+    private captureJointPose;
+    private captureJointPoseForTargets;
+    private resetPoseEditState;
+    private ensurePoseEditBaseline;
+    private markPoseEditDirty;
+    private dispatchPoseEditChange;
+    private dispatchJointHoverChange;
+    private restoreLastAnimatedPose;
+    private restoreInactiveAnimatedJoints;
+    private updateViewerDebugLayers;
+    private shouldEnableCameraControls;
+    private shouldShowInteractionHandles;
+    private ensureNavigationPreviewGroup;
+    private resolveNavigationPreviewPresentationFrame;
+    private applyNavigationPreviewPresentationTransform;
+    private clearNavigationPreviewObjects;
+    private addNavigationGizmoSegment;
+    private addNavigationOrientationGizmo;
+    private addNavigationGizmoLabel;
+    private handleNavigationDoubleClick;
+    private updateNavigationMarkerEasing;
+    private updateNavigationSimulation;
+    private captureNavigationSimulationPhysicsBaseline;
+    private projectNavigationSimulationToPhysicsRoot;
+    private ensurePoseHandleGroup;
+    private startPoseHandleTargetTransition;
+    private cancelPoseHandleTargetTransition;
+    private updatePoseHandleTargetTransition;
+    private applyPoseHandleTargetTransitionOpacity;
+    private updatePoseHandleVisibility;
+    private clearPoseHandles;
+    private updatePoseHandles;
+    private refreshPoseHandleProjection;
+    private resolvePoseInteractionHandles;
+    private resolveJointInteractionHandles;
+    private resolvePoseHandleLocalAnchorOffset;
+    private createPoseHandleMarker;
+    private createPoseHandleValueSignature;
+    private resolvePoseHandleAxisLayouts;
+    private resolvePoseHandleCenterRadius;
+    private createPoseHandleTexture;
+    private updatePoseHandleAppearance;
+    private updatePoseHandleScreenScale;
+    private isPoseHandleAnatomicallyOccluded;
+    private resolvePoseHandleVisibleBodyFamilies;
+    private resolvePoseHandleBodyFamilyFromObject;
+    private resolvePoseHandleBodyFamily;
+    private resolvePoseHandleSubjectScreenSpanPixels;
+    private resolveWorldUnitsPerScreenPixel;
+    private resolvePoseHandleScreenMetrics;
+    private resolvePoseHandleFromPointer;
+    private resolvePoseHandleAxisSelectionFromPointer;
+    private resolvePoseHandleAxisFromPointer;
+    private handlePoseHandlePointerMove;
+    private handlePoseHandlePointerDown;
+    private clearPoseHandleFocus;
+    private handlePoseHandlePointerUp;
+    private handlePoseHandlePointerLeave;
+    private handlePoseHandleClick;
+    private createPoseHandleDragState;
+    private resolveHandleJointAxes;
+    private createPoseHandleDragPlane;
+    private resolvePointerWorldPointOnPlane;
+    private dragPoseHandle;
+    private dragJointHandle;
+    private resolveActiveJointDragAxes;
+    private dragPosePreviewHandle;
+    private finishPoseHandleDrag;
+    private dispatchLivePoseTarget;
+    private ensureProjectileInteractionGroup;
+    private refreshProjectileAim;
+    private updateProjectileAimPresentation;
+    private syncProjectileSlingshotSegment;
+    private orientProjectileSlingshotPerpendicularToTangent;
+    private syncProjectileSlingshotPresentation;
+    private resolveProjectileSlingshotPouchPosition;
+    private beginProjectileSlingshotRelease;
+    private updateProjectileSlingshotRelease;
+    private updateProjectileCameraProjection;
+    private resolveProjectileIdleTarget;
+    private beginProjectileIdleTransition;
+    private updateProjectileAimTransition;
+    private createProjectileLaunchSolution;
+    private resolveProjectileChargeRatio;
+    private updateProjectileCharge;
+    private resolveProjectileLauncherOrigin;
+    private resolveDefaultProjectileTarget;
+    private resolveProjectileTargetFromPointer;
+    private resolveProjectilePhysicsBodyName;
+    private handleProjectilePointerMove;
+    private handleProjectilePointerEnter;
+    private handleProjectilePointerLeave;
+    private handleProjectileWindowBlur;
+    setInputBindingOverrides(overrides: readonly InteractionInputBindingOverride[]): void;
+    dispatchInteractionInput(signal: InteractionInputSignal): boolean;
+    private handleInteractionKeyDown;
+    private handleInteractionKeyUp;
+    private executeInteractionAction;
+    private launchProjectile;
+    private setProjectileParticlePhase;
+    private updateProjectileInteraction;
+    private resolveProjectileVisualScale;
+    private resolveProjectileRobotCollision;
+    private ensureProjectilePhysicsVisualAlignment;
+    private projectProjectilePhysicsObservation;
+    private resolveProjectilePhysicsColliderHit;
+    private projectViewerImpulseToPhysics;
+    private projectViewerPointToPhysics;
+    private isProjectilePhysicsReady;
+    private reportProjectileInteraction;
+    private cancelProjectileInteraction;
+    private clearProjectileInteraction;
+    private ensureContactPointGroup;
+    private updateContactPointVisibility;
+    private clearContactPoints;
+    private updateContactPoints;
+    private resolveContactPoints;
+    private createContactPointMarker;
+    private ensurePhysicsDebugGroup;
+    /** Physics diagnostics are authored in the SIM authority frame. */
+    private applyPhysicsDebugPresentationTransform;
+    private updatePhysicsDebugVisibility;
+    private shouldShowAnyPhysicsDebugLayer;
+    private clearPhysicsDebug;
+    private syncPhysicsDebugTransforms;
+    private syncPhysicsDebugEnvironment;
+    private ensurePhysicsDebugGroundMesh;
+    private ensurePhysicsDebugGravityArrow;
+    private resolvePhysicsDebugMarkerPosition;
+    private resolvePhysicsDebugMarkerQuaternion;
+    private resolvePhysicsDebugBodyPose;
+    private resolvePhysicsDebugMarkerPose;
+    private resolvePhysicsDebugBodyCenterOfMass;
+    private shouldDisplayPhysicsDebugBody;
+    private shouldDisplayPhysicsDebugLink;
+    private syncPhysicsDebugMarkerStyle;
+    private resolvePhysicsDebugMarkerScale;
+    private resolvePhysicsDebugMarkerRadius;
+    private resolvePhysicsDebugBodyMass;
+    private resolvePhysicsDebugMarkerColor;
+    private syncPhysicsDebugColliders;
+    private ensurePhysicsDebugColliderGroup;
+    private createPhysicsDebugColliderObject;
+    private createPhysicsDebugCapsuleCollider;
+    private createPhysicsDebugColliderMaterial;
+    private applyPhysicsDebugColliderLocalTransform;
+    private resolvePhysicsDebugColliderColor;
+    private resolvePhysicsDebugColliderProxies;
+    private resolvePhysicsDebugVisualJointPosition;
+    private hasPhysicsDebugVisualAnchor;
+    private resolvePhysicsDebugVisualObject;
+    private syncPhysicsDebugCoordinateFrame;
+    private resolvePhysicsDebugParentBodyName;
+    private syncPhysicsCenterOfMassMarker;
+    private ensurePhysicsCenterOfMassMarker;
+    private ensurePhysicsDebugMarker;
+    private ensurePhysicsDebugLink;
+    private createPhysicsDebugAxis;
+    private ensureEyeRingDebugGroup;
+    private updateEyeRingDebugVisibility;
+    private clearEyeRingDebug;
+    private updateEyeRingDebug;
+    private resolveEyeRingCalibration;
+    private resolveLedRingCalibrationZones;
+    private resolveFiniteCalibrationNumber;
+    private resolveLedLayout;
+    private resolveLedRingZoneCalibration;
+    private resolveEyeRingDebugDimensions;
+    private resolveEyeRingPose;
+    private resolvePoseControlEyeRingPose;
+    private resolveLedRingPoses;
+    private resolveHeadLedRingPoses;
+    private resolveTorsoLedRingPoses;
+    private resolveHandLedRingPoses;
+    private resolveFootLedRingPoses;
+    private resolveConfiguredLedRingPoses;
+    private createLedRingOrientationFromNormal;
+    private createLedLayoutGuide;
+    private createEyeRingCircle;
+    private createEyeRingLedMarker;
+    private createEyeRingMireLines;
+    private createEyeRingLine;
+    private ensureBalanceDebugGroup;
+    /** Physics coordinates are SIM-local; observed support points are world-space. */
+    private applyBalanceDebugPresentationOffset;
+    private updateBalanceDebugVisibility;
+    private clearBalanceDebug;
+    private updateBalanceDebug;
+    /**
+     * REAL currently exposes articulated joint telemetry but no admitted COM.
+     * Project its semantic foot contacts without copying the SIM-only COM and
+     * balance-risk result onto an incarnation that did not produce them.
+     */
+    private updateObservedBalanceDebug;
+    private updateBalanceDebugCenterOfMassFade;
+    private resolveBalanceDebugSupportPoints;
+    private createBalanceDebugBoundsSupportPoints;
+    private resolveBalanceDebugObservedContacts;
+    private resolveBalanceDebugPhysicsSupportPoints;
+    private resolveBalanceDebugColliderSamplePoints;
+    private createBalanceDebugColliderLocalMatrix;
+    private resolveBalanceDebugContactPoints;
+    private createBalanceDebugFootprintPoints;
+    private resolveBalanceDebugCenterOfMass;
+    private resolvePhysicsVectorViewerPosition;
+    private resolveBalanceDebugJointPosition;
+    private resolveBalanceDebugSupportPolygon;
+    private createBalanceDebugSupportOutline;
+    private createBalanceDebugSupportFill;
+    private evaluateBalanceDebugRisk;
+    private isBalanceDebugPointInsidePolygon;
+    private getBalanceDebugDistanceToPolygonEdge;
+    private getBalanceDebugDistanceToSegment;
+    private createBalanceDebugLine;
+    private createBalanceDebugMarker;
+    private createBalanceDebugCenterProjectionMarker;
+    private ensureTrajectoryGroup;
+    private updateTrajectoryGroupVisibility;
+    private clearTrajectoryPreview;
+    private rebuildTrajectoryPreview;
+    private getTrajectorySignature;
+    private getTrajectoryPreviewTargets;
+    private shouldRenderTrajectoryForTarget;
+    private resolveJointColor;
+    private createTrajectoryObject;
+    private getTrajectoryTerminalDirection;
+    private updateTrajectoryCurrentMarkers;
+    private getTrajectoryPoint;
+    private getHandTipTrajectoryPoint;
+    private getPoseControlHandTipPoint;
+    private getRobotHandTipPoint;
+    private getTrajectoryAnchor;
+    private getHandTipTrajectoryAnchor;
+    private getLocalMeshBounds;
+    private restoreJointPose;
+    private captureRobotTransform;
+    private restoreRobotTransform;
+    private restorePhysicsResetRobotState;
+    private restoreDefaultRobotState;
+    setCameraPose(position: RobotViewerVector, target?: RobotViewerVector, up?: RobotViewerVector): void;
+    orbitCameraBy(deltaYawRadians: number, deltaPitchRadians: number): void;
+    getCameraPose(): {
+        position: RobotViewerVector;
+        target: RobotViewerVector;
+        up: RobotViewerVector;
+        quaternion: RobotViewerQuaternion;
+        projection: Viewer3DCameraProjection;
+    };
+    resolveEyeRingCameraPose(viewId?: Viewer3DSymmetricCameraView): {
+        position: RobotViewerVector;
+        target: RobotViewerVector;
+        projection: Viewer3DCameraProjection;
+    } | null;
+    resolveRobotObjectCameraPose(anchorNames: readonly string[] | readonly (readonly string[])[], offset: RobotViewerVector, options?: {
+        targetOffset?: RobotViewerVector;
+        projection?: Viewer3DCameraProjection;
+    }): {
+        position: RobotViewerVector;
+        target: RobotViewerVector;
+        projection: Viewer3DCameraProjection;
+    } | null;
+    private serializeCameraVector;
+    private serializeCameraQuaternion;
+    private serializeRuntimeHistoryVector;
+    transitionCameraPose(position: RobotViewerVector, target?: RobotViewerVector, durationMs?: number, up?: RobotViewerVector): void;
+    resetCameraView(durationMs?: number): void;
+    private cancelCameraTransition;
+    private applyCameraPoseImmediate;
+    setCameraProjection(cameraProjection: Viewer3DCameraProjection): void;
+    setCameraControlMode(cameraControlMode: Viewer3DCameraControlMode): void;
+    private replaceCameraControls;
+    private handleControlsStart;
+    private handleControlsChange;
+    private handleControlsEnd;
+    private interpolateTrack;
+}
+export {};
+//# sourceMappingURL=Viewer3DRenderer.d.ts.map