mujoco-react 8.9.2 → 8.11.0

package/dist/types-BmneHLBM.d.ts

@@ -0,0 +1,871 @@
+import React__default, { ReactNode } from 'react';
+import { CanvasProps, ThreeElements } from '@react-three/fiber';
+import * as THREE from 'three';
+
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Module augmentation interface for type-safe resource names.
+ *
+ * Declare your model's resource names via module augmentation:
+ * ```ts
+ * declare module 'mujoco-react' {
+ *   interface Register {
+ *     robots: {
+ *       panda: {
+ *         actuators: 'joint1' | 'joint2' | 'gripper';
+ *         sensors: 'force_sensor' | 'torque_sensor';
+ *         bodies: 'link0' | 'link1' | 'hand';
+ *       };
+ *     };
+ *     actuators: 'joint1' | 'joint2' | 'gripper';
+ *     sensors: 'force_sensor' | 'torque_sensor';
+ *     bodies: 'link0' | 'link1' | 'hand';
+ *   }
+ * }
+ * ```
+ *
+ * When no augmentation is declared, all names fall back to `string`.
+ */
+interface Register {
+}
+type RegisteredRobotMap = Register extends {
+    robots: infer T extends Record<string, Record<string, string>>;
+} ? T : never;
+type Robots = [RegisteredRobotMap] extends [never] ? string : Extract<keyof RegisteredRobotMap, string>;
+type RobotResource<TRobot extends string, TKey extends string> = [
+    RegisteredRobotMap
+] extends [never] ? string : TRobot extends keyof RegisteredRobotMap ? TKey extends keyof RegisteredRobotMap[TRobot] ? RegisteredRobotMap[TRobot][TKey] : string : never;
+type RegisterResourceKey = 'actuators' | 'sensors' | 'bodies' | 'joints' | 'sites' | 'geoms' | 'keyframes';
+type RobotResourceObject<TRobot extends string, TKey extends RegisterResourceKey> = string extends RobotResource<TRobot, TKey> ? Record<string, string> : {
+    readonly [K in RobotResource<TRobot, TKey>]: K;
+};
+type RobotResourceCategory<TKey extends RegisterResourceKey> = string extends Robots ? Record<string, Record<string, string>> : {
+    readonly [TRobot in Robots]: RobotResourceObject<TRobot, TKey>;
+};
+type RobotResourceRegistry = string extends Robots ? Record<string, Record<RegisterResourceKey, Record<string, string>>> : {
+    readonly [TRobot in Robots]: {
+        readonly [TKey in RegisterResourceKey]: RobotResourceObject<TRobot, TKey>;
+    };
+};
+type RuntimeRobotResourceRegistration = Readonly<Record<string, Readonly<Record<RegisterResourceKey, Readonly<Record<string, string>>>>>>;
+declare function registerRobotResources(resources: RuntimeRobotResourceRegistration): void;
+declare const RobotResources: RobotResourceRegistry;
+type RobotActuators<TRobot extends string> = RobotResource<TRobot, 'actuators'>;
+declare const RobotActuators: RobotResourceCategory<'actuators'>;
+type RobotSensors<TRobot extends string> = RobotResource<TRobot, 'sensors'>;
+declare const RobotSensors: RobotResourceCategory<'sensors'>;
+type RobotBodies<TRobot extends string> = RobotResource<TRobot, 'bodies'>;
+declare const RobotBodies: RobotResourceCategory<'bodies'>;
+type RobotJoints<TRobot extends string> = RobotResource<TRobot, 'joints'>;
+declare const RobotJoints: RobotResourceCategory<'joints'>;
+type RobotSites<TRobot extends string> = RobotResource<TRobot, 'sites'>;
+declare const RobotSites: RobotResourceCategory<'sites'>;
+type RobotGeoms<TRobot extends string> = RobotResource<TRobot, 'geoms'>;
+declare const RobotGeoms: RobotResourceCategory<'geoms'>;
+type RobotKeyframes<TRobot extends string> = RobotResource<TRobot, 'keyframes'>;
+declare const RobotKeyframes: RobotResourceCategory<'keyframes'>;
+type Actuators = Register extends {
+    actuators: infer T extends string;
+} ? T : string;
+type Sensors = Register extends {
+    sensors: infer T extends string;
+} ? T : string;
+type Bodies = Register extends {
+    bodies: infer T extends string;
+} ? T : string;
+type Joints = Register extends {
+    joints: infer T extends string;
+} ? T : string;
+type Sites = Register extends {
+    sites: infer T extends string;
+} ? T : string;
+type Geoms = Register extends {
+    geoms: infer T extends string;
+} ? T : string;
+type Keyframes = Register extends {
+    keyframes: infer T extends string;
+} ? T : string;
+/**
+ * A single MuJoCo contact from the WASM module.
+ * Accessed via `data.contact.get(i)`.
+ */
+interface MujocoContact {
+    geom1: number;
+    geom2: number;
+    pos: Float64Array;
+    frame: Float64Array;
+    dist: number;
+}
+/**
+ * WASM contact array — supports indexed access via `.get(i)`.
+ */
+interface MujocoContactArray {
+    get(i: number): MujocoContact | undefined;
+    delete?: () => void;
+}
+/**
+ * Read a single contact from an already-acquired WASM contact array.
+ * Returns undefined if the access fails (WASM heap issue, bad index, etc.).
+ */
+declare function getContact(contacts: MujocoContactArray, i: number): MujocoContact | undefined;
+/**
+ * Minimal interface for MuJoCo Model to avoid 'any'.
+ */
+interface MujocoModel {
+    nbody: number;
+    ngeom: number;
+    nsite: number;
+    nu: number;
+    njnt: number;
+    nq: number;
+    nv: number;
+    nkey: number;
+    nsensor: number;
+    nsensordata: number;
+    nlight: number;
+    ntendon: number;
+    nflex: number;
+    nmesh: number;
+    nmat: number;
+    names: Int8Array;
+    name_bodyadr: Int32Array;
+    name_jntadr: Int32Array;
+    name_geomadr: Int32Array;
+    name_siteadr: Int32Array;
+    name_actuatoradr: Int32Array;
+    name_keyadr: Int32Array;
+    name_sensoradr: Int32Array;
+    name_tendonadr: Int32Array;
+    body_mass: Float64Array;
+    body_parentid: Int32Array;
+    body_jntnum: Int32Array;
+    body_jntadr: Int32Array;
+    body_pos: Float64Array;
+    body_quat: Float64Array;
+    body_geomnum: Int32Array;
+    body_geomadr: Int32Array;
+    body_inertia: Float64Array;
+    qpos0: Float64Array;
+    jnt_qposadr: Int32Array;
+    jnt_dofadr: Int32Array;
+    jnt_type: Int32Array;
+    jnt_range: Float64Array;
+    jnt_bodyid: Int32Array;
+    jnt_pos: Float64Array;
+    jnt_axis: Float64Array;
+    jnt_limited: Uint8Array;
+    geom_group: Int32Array;
+    geom_type: Int32Array;
+    geom_size: Float64Array;
+    geom_pos: Float64Array;
+    geom_quat: Float64Array;
+    geom_matid: Int32Array;
+    geom_rgba: Float32Array;
+    geom_dataid: Int32Array;
+    geom_bodyid: Int32Array;
+    geom_contype: Int32Array;
+    geom_conaffinity: Int32Array;
+    geom_friction: Float64Array;
+    mat_rgba: Float32Array;
+    mesh_vertadr: Int32Array;
+    mesh_vertnum: Int32Array;
+    mesh_faceadr: Int32Array;
+    mesh_facenum: Int32Array;
+    mesh_vert: Float32Array;
+    mesh_face: Int32Array;
+    mesh_normal: Float32Array;
+    site_bodyid: Int32Array;
+    actuator_trnid: Int32Array;
+    actuator_ctrlrange: Float64Array;
+    actuator_trntype: Int32Array;
+    actuator_gainprm: Float64Array;
+    actuator_biasprm: Float64Array;
+    sensor_type: Int32Array;
+    sensor_dim: Int32Array;
+    sensor_adr: Int32Array;
+    sensor_objtype: Int32Array;
+    sensor_objid: Int32Array;
+    key_qpos: Float64Array;
+    key_ctrl: Float64Array;
+    key_time: Float64Array;
+    key_qvel: Float64Array;
+    light_pos: Float64Array;
+    light_dir: Float64Array;
+    light_diffuse: Float32Array;
+    light_specular: Float32Array;
+    light_type: Int32Array;
+    light_active: Uint8Array;
+    light_castshadow: Uint8Array;
+    light_attenuation: Float32Array;
+    light_cutoff: Float32Array;
+    light_exponent: Float32Array;
+    light_intensity: Float32Array;
+    ten_wrapadr: Int32Array;
+    ten_wrapnum: Int32Array;
+    ten_range: Float64Array;
+    ten_rgba: Float32Array;
+    ten_width: Float64Array;
+    flex_vertadr: Int32Array;
+    flex_vertnum: Int32Array;
+    flex_faceadr: Int32Array;
+    flex_facenum: Int32Array;
+    flex_face: Int32Array;
+    flex_rgba: Float32Array;
+    opt: {
+        timestep: number;
+        gravity: Float64Array;
+        integrator: number;
+        [key: string]: unknown;
+    };
+    delete: () => void;
+    [key: string]: unknown;
+}
+/**
+ * Minimal interface for MuJoCo Data to avoid 'any'.
+ */
+interface MujocoData {
+    time: number;
+    qpos: Float64Array;
+    qvel: Float64Array;
+    ctrl: Float64Array;
+    act: Float64Array;
+    xpos: Float64Array;
+    xquat: Float64Array;
+    xfrc_applied: Float64Array;
+    qfrc_applied: Float64Array;
+    qfrc_bias: Float64Array;
+    site_xpos: Float64Array;
+    site_xmat: Float64Array;
+    sensordata: Float64Array;
+    ncon: number;
+    contact: MujocoContactArray;
+    cvel: Float64Array;
+    cfrc_ext: Float64Array;
+    ten_length: Float64Array;
+    wrap_xpos: Float64Array;
+    ten_wrapadr: Int32Array;
+    flexvert_xpos: Float64Array;
+    geom_xpos: Float64Array;
+    geom_xmat: Float64Array;
+    delete: () => void;
+    [key: string]: unknown;
+}
+/**
+ * Minimal interface for the MuJoCo WASM Module.
+ */
+interface MujocoModule {
+    MjModel: {
+        from_xml_path?: (path: string) => MujocoModel;
+        from_xml_string?: (xml: string, vfs?: unknown) => MujocoModel;
+        loadFromXML?: (path: string) => MujocoModel;
+        [key: string]: unknown;
+    };
+    MjData: new (model: MujocoModel) => MujocoData;
+    MjvOption: new () => {
+        delete: () => void;
+        [key: string]: unknown;
+    };
+    mj_forward: (m: MujocoModel, d: MujocoData) => void;
+    mj_step: (m: MujocoModel, d: MujocoData) => void;
+    mj_resetData: (m: MujocoModel, d: MujocoData) => void;
+    mj_step1: (m: MujocoModel, d: MujocoData) => void;
+    mj_step2: (m: MujocoModel, d: MujocoData) => void;
+    mj_applyFT: (model: MujocoModel, data: MujocoData, force: Float64Array, torque: Float64Array, point: Float64Array, bodyId: number, qfrc_target: Float64Array) => void;
+    mj_ray: (model: MujocoModel, data: MujocoData, pnt: Float64Array, vec: Float64Array, geomgroup: Uint8Array | null, flg_static: number, bodyexclude: number, geomid: Int32Array) => number;
+    mj_name2id: (model: MujocoModel, type: number, name: string) => number;
+    mjtObj: Record<string, number>;
+    mjtGeom: Record<string, number | {
+        value: number;
+    }>;
+    mjtJoint: Record<string, number | {
+        value: number;
+    }>;
+    mjtSensor: Record<string, number | {
+        value: number;
+    }>;
+    FS: {
+        writeFile: (path: string, content: string | Uint8Array) => void;
+        readFile: (path: string, opts?: {
+            encoding: string;
+        }) => string | Uint8Array;
+        mkdir: (path: string) => void;
+        unmount: (path: string) => void;
+    };
+    [key: string]: unknown;
+}
+interface SceneObject {
+    name: string;
+    type: 'box' | 'sphere' | 'cylinder';
+    size: [number, number, number];
+    position: [number, number, number];
+    rgba: [number, number, number, number];
+    mass?: number;
+    freejoint?: boolean;
+    friction?: string;
+    solref?: string;
+    solimp?: string;
+    condim?: number;
+    /** MuJoCo geom group. Group 3 is conventionally used for collision-only helper geoms. */
+    group?: number;
+}
+interface XmlPatch {
+    target: string;
+    inject?: string;
+    injectAfter?: string;
+    replace?: [string, string];
+}
+type LocalMujocoFile = File;
+interface LoadFromFilesOptions {
+    /** Entry MJCF/URDF file. Inferred from scene.xml, model.xml, robot.xml, or the first XML/URDF file when omitted. */
+    sceneFile?: string;
+    /** Additional MJCF environment XML files merged into the entry scene before MuJoCo compilation. */
+    environmentFiles?: string[];
+    homeJoints?: number[];
+    xmlPatches?: XmlPatch[];
+    sceneObjects?: SceneObject[];
+    onReset?: (model: MujocoModel, data: MujocoData) => void;
+}
+interface SceneConfig {
+    /** Base URL for fetching model files. The loader fetches `src + sceneFile` and follows dependencies. */
+    src: string;
+    /** Entry MJCF XML or URDF file name, e.g. 'scene.xml' or 'robot.urdf'. */
+    sceneFile: string;
+    /** Browser-selected files for local MJCF/URDF loading. Preserves webkitRelativePath when available. */
+    files?: readonly LocalMujocoFile[];
+    /**
+     * Additional MJCF environment XML files merged into the entry scene before compilation.
+     *
+     * Use this for static collision/physics layers such as a Gaussian-splat
+     * environment's proxy `scene.xml`; render the splat itself as a separate
+     * visual layer.
+     */
+    environmentFiles?: string[];
+    sceneObjects?: SceneObject[];
+    homeJoints?: number[];
+    xmlPatches?: XmlPatch[];
+    onReset?: (model: MujocoModel, data: MujocoData) => void;
+}
+type ResourceSelector<TInfo, TName extends string = string> = TName | readonly TName[] | RegExp | ((info: TInfo) => boolean);
+interface IkConfig {
+    /** MuJoCo site name for IK target. */
+    siteName: Sites;
+    /**
+     * Explicit joints for IK. When omitted, the controller infers scalar hinge/slide
+     * joints by walking from the site body to the model root.
+     */
+    joints?: ResourceSelector<JointInfo, Joints>;
+    /** Explicit actuators for IK control output. */
+    actuators?: ResourceSelector<ActuatorInfo, Actuators>;
+    /**
+     * Number of joints to solve for, assuming legacy contiguous qpos/ctrl layout
+     * starting at index 0. Prefer inferred IK or `joints`/`actuators`.
+     */
+    numJoints?: number;
+    /** Custom IK solver. When omitted, uses built-in Damped Least-Squares solver. */
+    ikSolveFn?: IKSolveFn;
+    /** DLS damping. Default: 0.01. */
+    damping?: number;
+    /** Max solver iterations. Default: 50. */
+    maxIterations?: number;
+}
+interface IkContextValue {
+    ikEnabledRef: React__default.RefObject<boolean>;
+    ikCalculatingRef: React__default.RefObject<boolean>;
+    ikTargetRef: React__default.RefObject<THREE.Group>;
+    siteIdRef: React__default.RefObject<number>;
+    setIkEnabled: (enabled: boolean) => void;
+    moveTarget: (pos: THREE.Vector3, duration?: number) => void;
+    syncTargetToSite: () => void;
+    solveIK: (pos: THREE.Vector3, quat: THREE.Quaternion, currentQ: number[]) => number[] | null;
+    getGizmoStats: () => {
+        pos: THREE.Vector3;
+        rot: THREE.Euler;
+    } | null;
+}
+interface SceneMarker {
+    id: number;
+    position: THREE.Vector3;
+    label: string;
+}
+interface PhysicsConfig {
+    gravity?: [number, number, number];
+    timestep?: number;
+    substeps?: number;
+    paused?: boolean;
+    speed?: number;
+}
+type IKSolveFn = (pos: THREE.Vector3, quat: THREE.Quaternion, currentQ: number[], context?: IKSolveContext) => number[] | null;
+interface IKSolveContext {
+    model: MujocoModel;
+    data: MujocoData;
+    siteId: number;
+    controlGroup: ControlGroupInfo;
+}
+type PhysicsStepCallback = (model: MujocoModel, data: MujocoData) => void;
+interface StateSnapshot {
+    time: number;
+    qpos: Float64Array;
+    qvel: Float64Array;
+    ctrl: Float64Array;
+    act: Float64Array;
+    qfrc_applied: Float64Array;
+}
+interface BodyInfo {
+    id: number;
+    name: string;
+    mass: number;
+    parentId: number;
+}
+interface JointInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    range: [number, number];
+    limited: boolean;
+    bodyId: number;
+    qposAdr: number;
+    dofAdr: number;
+}
+interface GeomInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    size: [number, number, number];
+    bodyId: number;
+}
+interface SiteInfo {
+    id: number;
+    name: string;
+    bodyId: number;
+}
+interface ActuatorInfo {
+    id: number;
+    name: string;
+    range: [number, number];
+}
+interface ActuatedJointInfo extends JointInfo {
+    actuatorId: number;
+    actuatorName: string;
+    ctrlAdr: number;
+    ctrlRange: [number, number];
+}
+interface ControlJointInfo extends JointInfo {
+    actuatorId: number | null;
+    actuatorName: string | null;
+    ctrlAdr: number | null;
+    ctrlRange: [number, number] | null;
+}
+interface ControlGroupSelector {
+    /** Infer a kinematic chain from a MuJoCo site. */
+    siteName?: Sites;
+    /** Infer a kinematic chain from a body. */
+    bodyName?: Bodies;
+    /** Select joints by name, names, regex, or predicate. */
+    joints?: ResourceSelector<JointInfo, Joints>;
+    /** Select actuators by name, names, regex, or predicate. */
+    actuators?: ResourceSelector<ActuatorInfo, Actuators>;
+}
+interface ControlGroupInfo {
+    /** Joints in solve/control order. */
+    joints: ControlJointInfo[];
+    /** Actuators in control output order. */
+    actuators: ActuatorInfo[];
+    /** qpos addresses for scalar hinge/slide joints. */
+    qposAdr: number[];
+    /** dof addresses for scalar hinge/slide joints. */
+    dofAdr: number[];
+    /** ctrl addresses matching writable actuators. */
+    ctrlAdr: number[];
+    readQpos(data: MujocoData): Float64Array;
+    readCtrl(data: MujocoData): Float64Array;
+    writeQpos(data: MujocoData, values: ArrayLike<number>): void;
+    writeCtrl(data: MujocoData, values: ArrayLike<number>): void;
+}
+interface SensorInfo {
+    id: number;
+    name: string;
+    type: number;
+    typeName: string;
+    dim: number;
+    adr: number;
+}
+interface ContactInfo {
+    geom1: number;
+    geom1Name: string;
+    geom2: number;
+    geom2Name: string;
+    pos: [number, number, number];
+    depth: number;
+}
+interface RayHit {
+    point: THREE.Vector3;
+    bodyId: number;
+    geomId: number;
+    distance: number;
+}
+interface ModelOptions {
+    timestep: number;
+    gravity: [number, number, number];
+    integrator: number;
+}
+interface TrajectoryFrame {
+    time: number;
+    qpos: Float64Array;
+    qvel?: Float64Array;
+    ctrl?: Float64Array;
+    sensordata?: Float64Array;
+}
+interface TrajectoryData {
+    frames: TrajectoryFrame[];
+    fps: number;
+}
+type PlaybackState = 'idle' | 'playing' | 'paused' | 'completed';
+interface KeyBinding {
+    actuator: Actuators;
+    delta?: number;
+    toggle?: [number, number];
+    set?: number;
+}
+interface KeyboardTeleopConfig {
+    bindings: Record<string, KeyBinding>;
+    enabled?: boolean;
+}
+type PolicyVector = Float32Array | Float64Array | number[];
+interface PolicyObservationInput {
+    model: MujocoModel;
+    data: MujocoData;
+}
+interface PolicyInferenceInput extends PolicyObservationInput {
+    observation: PolicyVector;
+}
+interface PolicyActionInput extends PolicyInferenceInput {
+    action: PolicyVector;
+}
+interface PolicyConfig {
+    frequency: number;
+    enabled?: boolean;
+    onObservation: (input: PolicyObservationInput) => PolicyVector;
+    /** Run policy inference. Omit to pass observations directly to `onAction` for custom inline controllers. */
+    infer?: (input: PolicyInferenceInput) => PolicyVector;
+    onAction: (input: PolicyActionInput) => void;
+}
+type ObservationOutput = 'float32' | 'float64';
+interface ObservationConfig {
+    /** Include scalar simulation time. */
+    time?: boolean;
+    /** Include all qpos values. */
+    qpos?: boolean;
+    /** Include all qvel values. */
+    qvel?: boolean;
+    /** Include all ctrl values. */
+    ctrl?: boolean;
+    /** Include all actuator activation values. */
+    act?: boolean;
+    /** Include all raw sensordata values. */
+    sensordata?: boolean;
+    /** Include named sensor values in the configured order. */
+    sensors?: readonly Sensors[];
+    /** Include named site world positions in the configured order. */
+    sites?: readonly Sites[];
+    /** Include world gravity projected into each named body's local frame. */
+    projectedGravity?: Bodies | readonly Bodies[];
+    /** Output array type. Defaults to Float32Array. */
+    output?: ObservationOutput;
+}
+interface ObservationLayoutItem {
+    name: string;
+    start: number;
+    size: number;
+}
+interface ObservationResult {
+    values: Float32Array | Float64Array;
+    layout: ObservationLayoutItem[];
+}
+interface ObservationHandle {
+    /** Read a fresh observation from the current live MuJoCo model/data refs. */
+    read(): ObservationResult;
+    /** Read just the vector values for policy inference. */
+    readValues(): Float32Array | Float64Array;
+}
+interface DebugProps {
+    showGeoms?: boolean;
+    showSites?: boolean;
+    showJoints?: boolean;
+    showContacts?: boolean;
+    showCOM?: boolean;
+    showInertia?: boolean;
+    showTendons?: boolean;
+}
+interface IkGizmoProps {
+    controller: IkContextValue;
+    siteName?: string;
+    scale?: number;
+    onDrag?: (position: THREE.Vector3, quaternion: THREE.Quaternion) => void;
+}
+interface DragInteractionProps {
+    stiffness?: number;
+    showArrow?: boolean;
+}
+interface SceneLightsProps {
+    /** Override intensity for all MJCF lights. Default: 1.0. */
+    intensity?: number;
+}
+type ScenarioLightingPreset = 'studio' | 'warehouse' | 'low-light' | 'splat';
+type SplatFormat = 'spz' | 'ply' | 'splat';
+type SplatRendererKind = 'spark' | 'custom';
+type SplatCollisionPrimitive = 'plane' | 'box' | 'sphere' | 'capsule' | 'mesh';
+interface ScenarioCameraConfig {
+    jitter?: number;
+    exposure?: number;
+    noise?: number;
+    blur?: number;
+}
+interface ScenarioMaterialConfig {
+    randomizeObjectColors?: boolean;
+    randomizeTableMaterial?: boolean;
+    roughness?: number;
+    metalness?: number;
+}
+interface SplatAssetConfig {
+    src: string;
+    /** Common browser-friendly splat format. Renderer-specific loaders may accept more. */
+    format?: SplatFormat;
+    /** Optional renderer hint. The library does not import renderer-specific code. */
+    renderer?: SplatRendererKind;
+}
+interface SplatScenarioConfig {
+    enabled: boolean;
+    /** Common browser-friendly splat format. Renderer-specific loaders may accept more. */
+    format?: SplatFormat;
+    src?: string;
+    requiresCollisionProxy?: boolean;
+    collisionProxy?: SplatCollisionProxyConfig | null;
+}
+interface SplatCollisionProxyConfig {
+    /** MJCF/XML file or artifact path that provides physics collision for the visual splat. */
+    xmlPath?: string;
+    /** Human-readable status for authoring and validation flows. */
+    status?: 'missing' | 'planned' | 'generated' | 'validated';
+    /** Primitive proxy shapes expected in the MJCF collision proxy. */
+    primitives?: SplatCollisionPrimitive[];
+    /** Optional notes that should travel with scene variants and rollout metadata. */
+    notes?: string[];
+}
+interface PairedSplatEnvironmentConfig {
+    id: string;
+    label: string;
+    description?: string;
+    /** Visual-only Gaussian splat asset. */
+    splat: SplatAssetConfig;
+    /** MJCF/XML contact geometry paired with the visual splat. */
+    collisionProxy: SplatCollisionProxyConfig & {
+        xmlPath: string;
+    };
+}
+interface SplatEnvironmentMetadataInput {
+    environment?: PairedSplatEnvironmentConfig;
+    scenario?: VisualScenarioConfig;
+    renderer?: SplatRendererKind;
+    src?: string;
+    format?: SplatFormat;
+    collisionProxy?: SplatCollisionProxyConfig;
+}
+interface SplatEnvironmentMetadata {
+    src?: string;
+    format: SplatFormat;
+    collisionProxy?: SplatCollisionProxyConfig;
+    userData: Record<string, unknown>;
+}
+type SplatSceneInput = PairedSplatEnvironmentConfig | VisualScenarioConfig | undefined | null;
+interface VisualScenarioConfig {
+    id?: string;
+    label?: string;
+    seed?: number;
+    lighting?: ScenarioLightingPreset;
+    environment?: string;
+    camera?: ScenarioCameraConfig;
+    materials?: ScenarioMaterialConfig;
+    splat?: SplatScenarioConfig | null;
+}
+interface ScenarioLightingProps {
+    preset?: ScenarioLightingPreset;
+    intensity?: number;
+    castShadow?: boolean;
+}
+interface SplatEnvironmentProps extends Omit<ThreeElements['group'], 'ref'> {
+    environment?: PairedSplatEnvironmentConfig;
+    scenario?: VisualScenarioConfig;
+    renderer?: SplatRendererKind;
+    src?: string;
+    format?: SplatFormat;
+    collisionProxy?: ReactNode;
+    collisionProxyMetadata?: SplatCollisionProxyConfig;
+    showPlaceholder?: boolean;
+}
+interface VisualScenarioEffectsProps {
+    scenario?: VisualScenarioConfig;
+    enabled?: boolean;
+    applyBackground?: boolean;
+    applyFog?: boolean;
+    applyRenderer?: boolean;
+    applyMaterials?: boolean;
+    background?: THREE.ColorRepresentation;
+    fogNear?: number;
+    fogFar?: number;
+    materialFilter?: (object: THREE.Object3D, material: THREE.Material) => boolean;
+}
+type TrajectoryInput = TrajectoryFrame[] | number[][];
+interface TrajectoryPlayerProps {
+    trajectory: TrajectoryInput;
+    fps?: number;
+    speed?: number;
+    loop?: boolean;
+    playing?: boolean;
+    mode?: 'kinematic' | 'physics';
+    onFrame?: (frameIdx: number) => void;
+    onComplete?: () => void;
+    onStateChange?: (state: PlaybackState) => void;
+}
+interface ContactListenerProps {
+    body: Bodies;
+    onContactEnter?: (info: ContactInfo) => void;
+    onContactExit?: (info: ContactInfo) => void;
+}
+interface BodyProps {
+    name: Bodies;
+    type: 'box' | 'sphere' | 'cylinder';
+    size: [number, number, number];
+    position?: [number, number, number];
+    rgba?: [number, number, number, number];
+    mass?: number;
+    freejoint?: boolean;
+    friction?: string;
+    solref?: string;
+    solimp?: string;
+    condim?: number;
+    /** MuJoCo geom group. Group 3 is conventionally used for collision-only helper geoms. */
+    group?: number;
+    children?: ReactNode;
+}
+interface MujocoSimAPI {
+    readonly status: 'loading' | 'ready' | 'error';
+    readonly config: SceneConfig;
+    reset(): void;
+    setSpeed(multiplier: number): void;
+    togglePause(): boolean;
+    setPaused(paused: boolean): void;
+    step(n?: number): void;
+    getTime(): number;
+    getTimestep(): number;
+    applyKeyframe(nameOrIndex: Keyframes | number): void;
+    saveState(): StateSnapshot;
+    restoreState(snapshot: StateSnapshot): void;
+    setQpos(values: Float64Array | number[]): void;
+    setQvel(values: Float64Array | number[]): void;
+    getQpos(): Float64Array;
+    getQvel(): Float64Array;
+    setCtrl(nameOrValues: Actuators | Record<Actuators, number>, value?: number): void;
+    getCtrl(): Float64Array;
+    getControlMap(): ControlGroupInfo;
+    getActuatedJoints(): ActuatedJointInfo[];
+    resolveControlGroup(selector: ControlGroupSelector): ControlGroupInfo | null;
+    applyForce(bodyName: Bodies, force: THREE.Vector3, point?: THREE.Vector3): void;
+    applyTorque(bodyName: Bodies, torque: THREE.Vector3): void;
+    setExternalForce(bodyName: Bodies, force: THREE.Vector3, torque: THREE.Vector3): void;
+    applyGeneralizedForce(values: Float64Array | number[]): void;
+    getSensorData(name: Sensors): Float64Array | null;
+    getContacts(): ContactInfo[];
+    getBodies(): BodyInfo[];
+    getJoints(): JointInfo[];
+    getGeoms(): GeomInfo[];
+    getSites(): SiteInfo[];
+    getActuators(): ActuatorInfo[];
+    getSensors(): SensorInfo[];
+    getModelOption(): ModelOptions;
+    setGravity(g: [number, number, number]): void;
+    setTimestep(dt: number): void;
+    raycast(origin: THREE.Vector3, direction: THREE.Vector3, maxDist?: number): RayHit | null;
+    getKeyframeNames(): string[];
+    getKeyframeCount(): number;
+    loadScene(newConfig: SceneConfig): Promise<void>;
+    loadFromFiles(files: FileList | readonly LocalMujocoFile[], options?: LoadFromFilesOptions): Promise<void>;
+    addBody(body: SceneObject): Promise<void>;
+    removeBody(name: Bodies): Promise<void>;
+    recompile(patches?: XmlPatch[]): Promise<void>;
+    getCanvasSnapshot(width?: number, height?: number, mimeType?: string): string;
+    project2DTo3D(x: number, y: number, cameraPos: THREE.Vector3, lookAt: THREE.Vector3): {
+        point: THREE.Vector3;
+        bodyId: number;
+        geomId: number;
+    } | null;
+    setBodyMass(name: Bodies, mass: number): void;
+    setGeomFriction(name: Geoms, friction: [number, number, number]): void;
+    setGeomSize(name: Geoms, size: [number, number, number]): void;
+    readonly mjModelRef: React__default.RefObject<MujocoModel | null>;
+    readonly mjDataRef: React__default.RefObject<MujocoData | null>;
+}
+type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
+    config: SceneConfig;
+    /** R3F content rendered while the MuJoCo WASM module is still loading. */
+    loadingFallback?: ReactNode;
+    onReady?: (api: MujocoSimAPI) => void;
+    onError?: (error: Error) => void;
+    onStep?: (time: number) => void;
+    onSelection?: (bodyId: number, name: string) => void;
+    gravity?: [number, number, number];
+    timestep?: number;
+    substeps?: number;
+    paused?: boolean;
+    speed?: number;
+    interpolate?: boolean;
+};
+interface SitePositionResult {
+    position: React__default.RefObject<THREE.Vector3>;
+    quaternion: React__default.RefObject<THREE.Quaternion>;
+}
+interface MujocoContextValue {
+    mujoco: MujocoModule | null;
+    status: 'loading' | 'ready' | 'error';
+    error: string | null;
+}
+/** @deprecated Use `SensorHandle` instead. */
+interface SensorResult {
+    value: React__default.RefObject<Float64Array>;
+    size: number;
+}
+interface CtrlHandle {
+    /** Read the current ctrl value. */
+    read(): number;
+    /** Write a ctrl value (goes directly to data.ctrl). */
+    write(value: number): void;
+    /** Actuator name. */
+    name: Actuators;
+    /** Actuator control range [min, max]. */
+    range: [number, number];
+}
+interface SensorHandle {
+    /** Read the current sensor data. */
+    read(): Float64Array;
+    /** Sensor dimensionality. */
+    dim: number;
+    /** Sensor name. */
+    name: Sensors;
+}
+interface BodyStateResult {
+    position: React__default.RefObject<THREE.Vector3>;
+    quaternion: React__default.RefObject<THREE.Quaternion>;
+    linearVelocity: React__default.RefObject<THREE.Vector3>;
+    angularVelocity: React__default.RefObject<THREE.Vector3>;
+}
+interface JointStateResult {
+    position: React__default.RefObject<number | Float64Array>;
+    velocity: React__default.RefObject<number | Float64Array>;
+}
+
+export { type TrajectoryInput as $, type ActuatedJointInfo as A, type BodyProps as B, type ControlGroupInfo as C, type DragInteractionProps as D, type SitePositionResult as E, type Sensors as F, type GeomInfo as G, type SensorHandle as H, type IkConfig as I, type SensorInfo as J, type Joints as K, type JointStateResult as L, type MujocoContextValue as M, type Bodies as N, type ObservationConfig as O, type PhysicsStepCallback as P, type BodyStateResult as Q, type Actuators as R, type SceneConfig as S, type TrajectoryPlayerProps as T, type CtrlHandle as U, type VisualScenarioEffectsProps as V, type ContactInfo as W, type KeyboardTeleopConfig as X, type PolicyConfig as Y, type PolicyVector as Z, type ObservationHandle as _, type MujocoCanvasProps as a, type PlaybackState as a0, type TrajectoryFrame as a1, type BodyInfo as a2, type ControlJointInfo as a3, type Geoms as a4, type IKSolveFn as a5, type JointInfo as a6, type KeyBinding as a7, type Keyframes as a8, type ModelOptions as a9, type SensorResult as aA, type SiteInfo as aB, type SplatAssetConfig as aC, type SplatScenarioConfig as aD, type StateSnapshot as aE, type TrajectoryData as aF, type XmlPatch as aG, getContact as aH, registerRobotResources as aI, type MujocoContact as aa, type MujocoContactArray as ab, type ObservationLayoutItem as ac, type ObservationOutput as ad, type PhysicsConfig as ae, type PolicyActionInput as af, type PolicyInferenceInput as ag, type PolicyObservationInput as ah, type RayHit as ai, type Register as aj, type RegisteredRobotMap as ak, type ResourceSelector as al, RobotActuators as am, RobotBodies as an, RobotGeoms as ao, RobotJoints as ap, RobotKeyframes as aq, type RobotResource as ar, RobotResources as as, RobotSensors as at, RobotSites as au, type Robots as av, type ScenarioCameraConfig as aw, type ScenarioMaterialConfig as ax, type SceneMarker as ay, type SceneObject as az, type MujocoSimAPI as b, type MujocoModule as c, type MujocoModel as d, type MujocoData as e, type ControlGroupSelector as f, type ObservationResult as g, type IkContextValue as h, type IkGizmoProps as i, type SceneLightsProps as j, type ScenarioLightingProps as k, type SplatEnvironmentProps as l, type VisualScenarioConfig as m, type SplatRendererKind as n, type PairedSplatEnvironmentConfig as o, type SplatFormat as p, type SplatCollisionProxyConfig as q, type SplatCollisionPrimitive as r, type ScenarioLightingPreset as s, type SplatEnvironmentMetadataInput as t, type SplatEnvironmentMetadata as u, type SplatSceneInput as v, type DebugProps as w, type ContactListenerProps as x, type ActuatorInfo as y, type Sites as z };