mujoco-react 0.3.0 → 2.0.0

package/README.md

@@ -1,7 +1,12 @@
+<p align="center">
+  <img src="docs/images/mj2.gif" alt="mujoco-react demo" width="100%" />
+</p>
+
 # mujoco-react
 
-A thin, unopinionated wrapper around [mujoco-js](https://github.com/nicepkg/mujoco-js) — composable and extensible via React. Built on [React Three Fiber](https://docs.pmnd.rs/react-three-fiber). Works with **any robot, any scene**.
+Composable [React Three Fiber](https://docs.pmnd.rs/react-three-fiber) wrapper around [mujoco-js](https://www.npmjs.com/package/mujoco-js). Load any MuJoCo model, step physics, render bodies, and write controllers as React components.
 
+**[Live Demo](https://mujoco-react-example.pages.dev)** | **[Docs](https://dadd.mintlify.app)** | **[Example Source](https://github.com/noah-wardlow/mujoco-react-example)**
 
 ## Install
 
@@ -15,7 +20,6 @@ npm install mujoco-react three @react-three/fiber @react-three/drei
 import {
   MujocoProvider,
   MujocoCanvas,
-  SceneRenderer,
   IkController,
   IkGizmo,
 } from 'mujoco-react';
@@ -41,7 +45,6 @@ function App() {
         style={{ width: '100%', height: '100vh' }}
       >
         <OrbitControls enableDamping makeDefault />
-        <SceneRenderer />
         <IkController config={{ siteName: 'tcp', numJoints: 7 }}>
           <IkGizmo />
         </IkController>
@@ -53,32 +56,101 @@ function App() {
 }
 ```
 
+## Direct WASM Access
+
+`useMujoco()` gives you the full typed MuJoCo WASM binary — `mj_step`, `mj_forward`, `MjModel`, `MjData`, and everything else:
+
+```tsx
+import { useMujoco } from 'mujoco-react';
+
+const { mujoco, status } = useMujoco();
+
+if (mujoco) {
+  const model = mujoco.MjModel.loadFromXML('/path/to/scene.xml');
+  const data = new mujoco.MjData(model);
+  mujoco.mj_step(model, data);
+  console.log(data.qpos);  // joint positions after one step
+}
+```
+
+Most users won't need this — `<MujocoCanvas>` and hooks like `useBeforePhysicsStep` handle the model/data lifecycle for you. But the raw module is always available when you need it.
+
+## Writing a Controller
+
+A controller is a React component that calls `useBeforePhysicsStep` to write `data.ctrl` each frame:
+
+```tsx
+import { useBeforePhysicsStep } from 'mujoco-react';
+
+function MyController() {
+  useBeforePhysicsStep((_model, data) => {
+    data.ctrl[0] = Math.sin(data.time);        // sine wave on actuator 0
+    data.ctrl[1] = data.sensordata[0] * -0.5;  // feedback from a sensor
+  });
+  return null;
+}
+```
+
+Drop it into the tree:
+
+```tsx
+<MujocoCanvas config={config}>
+  <MyController />
+</MujocoCanvas>
+```
+
+The `createController<TConfig>()` factory adds typed config and default merging for reusable plugins:
+
+```tsx
+import { createController, useBeforePhysicsStep } from 'mujoco-react';
+
+export const MyController = createController<{ gain: number }>(
+  { name: 'MyController', defaultConfig: { gain: 1.0 } },
+  ({ config }) => {
+    useBeforePhysicsStep((_model, data) => {
+      data.ctrl[0] = config.gain * Math.sin(data.time);
+    });
+    return null;
+  },
+);
+
+// <MyController config={{ gain: 2.0 }} />
+```
+
 ## Architecture
 
+`<MujocoCanvas>` wraps R3F `<Canvas>` and forwards all Canvas props (`camera`, `shadows`, `gl`, etc.). For full control over the Canvas, use `<MujocoPhysics>` inside your own:
+
 ```
-<MujocoProvider>              <- WASM module lifecycle
-  <MujocoCanvas config={...}> <- Thin R3F Canvas wrapper + physics context
-    <OrbitControls />          <- You add your own controls
-    <SceneRenderer />          <- Syncs MuJoCo bodies to Three.js meshes
-    <IkController config={..}> <- Opt-in controller plugin
-      <IkGizmo />              <- PivotControls-based IK handle
-    </IkController>
-    <YourController />         <- Bring your own controller
-    <YourLights />             <- You compose your own scene
-    <YourGrid />
-  </MujocoCanvas>
-</MujocoProvider>
+<MujocoProvider>                           <MujocoProvider>
+  <MujocoCanvas config={...}>               <Canvas shadows gl={...}>
+    <IkController config={..}>                <MujocoPhysics config={...}>
+      <IkGizmo />                               <MyController />
+    </IkController>                           </MujocoPhysics>
+    <MyController />                          <EffectComposer>...</EffectComposer>
+  </MujocoCanvas>                           </Canvas>
+</MujocoProvider>                         </MujocoProvider>
 ```
 
-The library provides **only MuJoCo engine concerns**: WASM lifecycle, physics stepping, and body rendering. Controllers (IK, teleoperation, RL policies) are composable plugins you opt into — or bring your own.
+### Custom IK Solvers
 
-## Controller Plugins
+The built-in `<IkController>` uses Damped Least-Squares. Pass `ikSolveFn` to swap in your own solver (analytical, learned, etc.):
 
-Controllers are opt-in plugins that compose library hooks. The library ships `IkController` built with the `createController` factory, but the real power is building your own.
+```tsx
+import type { IKSolveFn } from 'mujoco-react';
+
+const myIK: IKSolveFn = (pos, quat, currentQ) => {
+  return myAnalyticalSolver(pos, currentQ); // return joint angles or null
+};
+
+<IkController config={{ siteName: 'tcp', numJoints: 7, ikSolveFn: myIK }}>
+  <IkGizmo />
+</IkController>
+```
 
 ### `<IkController>`
 
-The built-in IK controller. Wraps children with IK context — `<IkGizmo>` must be a descendant.
+The library includes one controller for interactive end-effector control:
 
 ```tsx
 <IkController config={{ siteName: 'tcp', numJoints: 7 }}>
@@ -94,9 +166,7 @@ The built-in IK controller. Wraps children with IK context — `<IkGizmo>` must
 | `damping` | `number` | `0.01` | DLS damping |
 | `maxIterations` | `number` | `50` | Max solver iterations |
 
-### `useIk()`
-
-Access IK state from inside `<IkController>`:
+Access IK state from inside `<IkController>` with `useIk()`:
 
 ```tsx
 const { setIkEnabled, moveTarget, solveIK } = useIk();
@@ -106,36 +176,6 @@ Pass `{ optional: true }` for components that may or may not be inside an `<IkCo
 
 ```tsx
 const ikCtx = useIk({ optional: true });
-if (ikCtx?.ikEnabledRef.current) {
-  ikCtx.setIkEnabled(false);
-}
-```
-
-### `createController<TConfig>(options, Impl)`
-
-Build your own controller plugin with the typed factory:
-
-```tsx
-import { createController, useBeforePhysicsStep, useMujocoSim } from 'mujoco-react';
-
-interface MyConfig {
-  gain: number;
-  targetJoint: string;
-}
-
-function MyControllerImpl({ config }: { config: MyConfig; children?: React.ReactNode }) {
-  useBeforePhysicsStep((_model, data) => {
-    data.ctrl[0] = config.gain * Math.sin(data.time);
-  });
-  return null;
-}
-
-export const MyController = createController<MyConfig>(
-  { name: 'MyController', defaultConfig: { gain: 1.0 } },
-  MyControllerImpl,
-);
-
-// Usage: <MyController config={{ gain: 2.0, targetJoint: 'shoulder' }} />
 ```
 
 ## Loading Models
@@ -143,7 +183,7 @@ export const MyController = createController<MyConfig>(
 Models are loaded from any HTTP source via `SceneConfig.baseUrl`. Defaults to [MuJoCo Menagerie](https://github.com/google-deepmind/mujoco_menagerie) on GitHub.
 
 ```tsx
-// Menagerie robots — just set robotId
+// Menagerie robots: just set robotId
 const franka: SceneConfig = {
   robotId: 'franka_emika_panda',
   sceneFile: 'scene.xml',
@@ -233,13 +273,34 @@ Thin wrapper around R3F `<Canvas>`. Accepts all R3F Canvas props plus:
 | `substeps` | `number` | mj_step calls per frame |
 | `paused` | `boolean` | Declarative pause |
 | `speed` | `number` | Simulation speed multiplier |
-| `interpolate` | `boolean` | Interpolate body transforms between physics frames |
-| `gravityCompensation` | `boolean` | Auto-apply gravity compensation |
-| `mjcfLights` | `boolean` | Auto-create lights from MJCF model |
 
-### `<SceneRenderer />`
+### `<MujocoPhysics>`
 
-Syncs MuJoCo bodies to Three.js meshes every frame. Must be inside `<MujocoCanvas>`.
+Physics provider for use inside your own R3F `<Canvas>`. Same physics props as `<MujocoCanvas>` without the Canvas wrapper. Accepts a `ref` for the `MujocoSimAPI`.
+
+```tsx
+<MujocoProvider>
+  <Canvas shadows camera={{ position: [2, 2, 2] }}>
+    <MujocoPhysics ref={apiRef} config={config} paused={paused}>
+      <MyController />
+    </MujocoPhysics>
+    <OrbitControls />
+  </Canvas>
+</MujocoProvider>
+```
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `config` | `SceneConfig` | **Required.** Scene/robot configuration |
+| `onReady` | `(api: MujocoSimAPI) => void` | Fires when model is loaded |
+| `onError` | `(error: Error) => void` | Fires on scene load failure |
+| `onStep` | `(time: number) => void` | Called each physics step |
+| `onSelection` | `(bodyId: number, name: string) => void` | Called on double-click |
+| `gravity` | `[number, number, number]` | Override model gravity |
+| `timestep` | `number` | Override model.opt.timestep |
+| `substeps` | `number` | mj_step calls per frame |
+| `paused` | `boolean` | Declarative pause |
+| `speed` | `number` | Simulation speed multiplier |
 
 ### `<IkGizmo />`
 
@@ -255,6 +316,15 @@ drei PivotControls gizmo that tracks a MuJoCo site and drives IK on drag. Must b
 
 Click-drag to apply spring forces to bodies. Raycasts to find bodies, applies `F = (mouseWorld - grabWorld) * body_mass * stiffness` via `mj_applyFT`.
 
+### R3F Group Props
+
+All visual components (`DragInteraction`, `ContactMarkers`, `Debug`, `TendonRenderer`, `FlexRenderer`) accept standard R3F group props like `position`, `rotation`, `scale`, `visible`.
+
+```tsx
+<ContactMarkers visible={showContacts} />
+<Debug showJoints scale={0.5} />
+```
+
 ### `<ContactMarkers />`
 
 InstancedMesh showing MuJoCo contact points for debugging.
@@ -318,9 +388,23 @@ Plays back recorded qpos trajectories with scrubbing.
 
 ## Hooks
 
+### `useMujoco()`
+
+Access the WASM module lifecycle from any child of `<MujocoProvider>`:
+
+```tsx
+const { mujoco, status, error } = useMujoco();
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `mujoco` | `MujocoModule \| null` | The raw WASM module, or `null` while loading |
+| `status` | `'pending' \| 'error'` | Lifecycle state (absent once loaded) |
+| `error` | `string \| null` | Error message if loading failed |
+
 ### `useMujocoSim()`
 
-Access the simulation API and internal refs:
+Access the simulation API and internal refs (must be inside `<MujocoCanvas>` or `<MujocoPhysics>`):
 
 ```tsx
 const { api, mjModelRef, mjDataRef } = useMujocoSim();
@@ -577,34 +661,7 @@ The full API object available via `ref` or `useMujocoSim().api`:
 
 ### Building Controllers
 
-Controllers are thin components that compose library hooks. The simplest is a `useKeyboardTeleop` call:
-
-```tsx
-function FrankaController() {
-  useKeyboardTeleop({
-    bindings: { v: { actuator: 'gripper', toggle: [0, 255] } },
-  });
-  return null;
-}
-```
-
-For custom control (IK solvers, velocity control), use `useBeforePhysicsStep`:
-
-```tsx
-function MyController() {
-  const keys = useRef<Record<string, boolean>>({});
-  // ... keyboard listeners ...
-
-  useBeforePhysicsStep((_model, data) => {
-    if (keys.current['KeyW']) data.ctrl[0] += 0.01;
-  });
-  return null;
-}
-```
-
-For reusable controller plugins, use `createController<TConfig>()` to build typed components with config merging and metadata.
-
-See [Building Controllers](https://mujoco-react.mintlify.app/guides/building-controllers) for config-driven patterns, IK gizmo coexistence, and multi-arm support.
+See [Building Controllers](https://dadd.mintlify.app/guides/building-controllers) for full patterns including config-driven controllers, IK gizmo coexistence, multi-arm support, and the `createController` factory.
 
 ### Graspable Objects
 
@@ -626,7 +683,7 @@ sceneObjects: [{
 }]
 ```
 
-Without `condim: 4` and high friction, objects slide out of the gripper when lifted. See [Graspable Objects](https://mujoco-react.mintlify.app/guides/graspable-objects) for details.
+Without `condim: 4` and high friction, objects slide out of the gripper when lifted. See [Graspable Objects](https://dadd.mintlify.app/guides/graspable-objects) for details.
 
 ### Click-to-Select
 
@@ -639,14 +696,14 @@ function ClickSelectOverlay() {
 }
 ```
 
-See [Click-to-Select](https://mujoco-react.mintlify.app/guides/click-to-select) for the full implementation.
+See [Click-to-Select](https://dadd.mintlify.app/guides/click-to-select) for the full implementation.
 
 ## useFrame Priority
 
 | Priority | Owner | Purpose |
 |----------|-------|---------|
 | -1 | MujocoSimProvider | beforeStep, mj_step, afterStep |
-| 0 (default) | SceneRenderer, IkController, your code | Body mesh sync, IK, rendering |
+| 0 (default) | SceneRenderer (internal), IkController, your code | Body mesh sync, IK, rendering |
 
 ## Roadmap
 
@@ -658,7 +715,7 @@ Features planned but not yet implemented:
 | **URDF loading** | P2 | Load URDF models via MuJoCo's built-in URDF compiler |
 | **XML mutation / recompile** | P1 | `addBody()`, `removeBody()`, `recompile()` for runtime XML editing |
 | **Observation builder utilities** | P2 | Helpers for projected gravity, joint positions/velocities for RL |
-| **Physics interpolation** | P1 | Smooth rendering between physics ticks for 120Hz+ displays |
+| **Physics interpolation** | P1 | Smooth rendering between physics ticks for very high refresh displays |
 | **Instanced geom rendering** | P2 | `<InstancedGeomRenderer />` for particle/granular sims |
 | **Web Worker physics** | P2 | Run `mj_step` off main thread via SharedArrayBuffer |
 

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { CanvasProps } from '@react-three/fiber';
+import { CanvasProps, ThreeElements } from '@react-three/fiber';
 import * as THREE from 'three';
 import * as react from 'react';
 
@@ -240,12 +240,6 @@ interface SceneConfig {
     homeJoints?: number[];
     xmlPatches?: XmlPatch[];
     onReset?: (model: MujocoModel, data: MujocoData) => void;
-    /** @deprecated Use IkController config.siteName instead. */
-    tcpSiteName?: string;
-    /** @deprecated Use your own gripper control logic instead. */
-    gripperActuatorName?: string;
-    /** @deprecated Use IkController config.numJoints instead. */
-    numArmJoints?: number;
 }
 interface IkConfig {
     /** MuJoCo site name for IK target. */
@@ -270,7 +264,6 @@ interface PhysicsConfig {
     substeps?: number;
     paused?: boolean;
     speed?: number;
-    interpolate?: boolean;
 }
 type IKSolveFn = (pos: THREE.Vector3, quat: THREE.Quaternion, currentQ: number[]) => number[] | null;
 type PhysicsStepCallback = (model: MujocoModel, data: MujocoData) => void;
@@ -470,9 +463,6 @@ type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
     substeps?: number;
     paused?: boolean;
     speed?: number;
-    interpolate?: boolean;
-    gravityCompensation?: boolean;
-    mjcfLights?: boolean;
 };
 interface SitePositionResult {
     position: React.RefObject<THREE.Vector3>;
@@ -524,6 +514,50 @@ declare function MujocoProvider({ wasmUrl, timeout, children, onError }: MujocoP
  */
 declare const MujocoCanvas: react.ForwardRefExoticComponent<Omit<MujocoCanvasProps, "ref"> & react.RefAttributes<MujocoSimAPI>>;
 
+interface MujocoPhysicsProps {
+    /** Scene/robot configuration. */
+    config: SceneConfig;
+    /** Fires when model is loaded and API is ready. */
+    onReady?: (api: MujocoSimAPI) => void;
+    /** Fires on scene load failure. */
+    onError?: (error: Error) => void;
+    /** Called each physics step. */
+    onStep?: (time: number) => void;
+    /** Called on body double-click selection. */
+    onSelection?: (bodyId: number, name: string) => void;
+    /** Override model gravity. */
+    gravity?: [number, number, number];
+    /** Override model.opt.timestep. */
+    timestep?: number;
+    /** mj_step calls per frame. */
+    substeps?: number;
+    /** Declarative pause. */
+    paused?: boolean;
+    /** Simulation speed multiplier. */
+    speed?: number;
+    children: React.ReactNode;
+}
+/**
+ * MujocoPhysics — physics provider for use inside a user-owned R3F Canvas.
+ *
+ * This is the R3F-idiomatic alternative to MujocoCanvas. Instead of wrapping
+ * the Canvas, place this inside your own <Canvas>:
+ *
+ * ```tsx
+ * <MujocoProvider>
+ *   <Canvas shadows camera={...}>
+ *     <MujocoPhysics config={config} paused={paused}>
+ *       <SceneRenderer />
+ *       <OrbitControls />
+ *     </MujocoPhysics>
+ *   </Canvas>
+ * </MujocoProvider>
+ * ```
+ *
+ * Forward ref exposes MujocoSimAPI.
+ */
+declare const MujocoPhysics: react.ForwardRefExoticComponent<MujocoPhysicsProps & react.RefAttributes<MujocoSimAPI>>;
+
 interface MujocoSimContextValue {
     api: MujocoSimAPI;
     mjModelRef: React.RefObject<MujocoModel | null>;
@@ -555,10 +589,9 @@ interface MujocoSimProviderProps {
     substeps?: number;
     paused?: boolean;
     speed?: number;
-    interpolate?: boolean;
     children: React.ReactNode;
 }
-declare function MujocoSimProvider({ mujoco, config, apiRef: externalApiRef, onReady, onError, onStep, onSelection, gravity, timestep, substeps, paused, speed, interpolate, children, }: MujocoSimProviderProps): react_jsx_runtime.JSX.Element;
+declare function MujocoSimProvider({ mujoco, config, apiRef: externalApiRef, onReady, onError, onStep, onSelection, gravity, timestep, substeps, paused, speed, children, }: MujocoSimProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
  * @license
@@ -604,8 +637,6 @@ declare function findTendonByName(mjModel: MujocoModel, name: string): number;
 interface LoadResult {
     mjModel: MujocoModel;
     mjData: MujocoData;
-    siteId: number;
-    gripperId: number;
 }
 /**
  * Config-driven scene loader — replaces the old RobotLoader + patchSingleRobot approach.
@@ -687,16 +718,6 @@ declare function useIk(options: {
     optional: true;
 }): IkContextValue | null;
 
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * SceneRenderer — creates and syncs MuJoCo body meshes every frame.
- * Replaces RenderSystem.initScene() + RenderSystem.update() body loop.
- */
-declare function SceneRenderer(): react_jsx_runtime.JSX.Element;
-
 /**
  * IkGizmo — drei PivotControls that tracks a MuJoCo site.
  *
@@ -711,15 +732,6 @@ declare function SceneRenderer(): react_jsx_runtime.JSX.Element;
  */
 declare function IkGizmo({ siteName, scale, onDrag }: IkGizmoProps): react_jsx_runtime.JSX.Element | null;
 
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- *
- * ContactMarkers — instanced sphere visualization of MuJoCo contacts (spec 6.2)
- *
- * Fixed from original: reads data.ncon first, accesses contact via .get(i),
- * limits to maxContacts to avoid WASM heap OOM.
- */
 interface ContactMarkersProps {
     /** Maximum contacts to render. Default: 100. */
     maxContacts?: number;
@@ -730,7 +742,7 @@ interface ContactMarkersProps {
     /** Show markers. Default: true. */
     visible?: boolean;
 }
-declare function ContactMarkers({ maxContacts, radius, color, visible, }?: ContactMarkersProps): react_jsx_runtime.JSX.Element | null;
+declare function ContactMarkers({ maxContacts, radius, color, visible, ...groupProps }?: ContactMarkersProps & Omit<ThreeElements['group'], 'ref' | 'visible'>): react_jsx_runtime.JSX.Element | null;
 
 /**
  * DragInteraction — Ctrl/Cmd+click-drag to apply spring forces to MuJoCo bodies.
@@ -745,7 +757,7 @@ declare function ContactMarkers({ maxContacts, radius, color, visible, }?: Conta
  * Forces compose with useGravityCompensation — the provider zeros
  * qfrc_applied each frame, then all consumers add to it.
  */
-declare function DragInteraction({ stiffness, showArrow, }: DragInteractionProps): react_jsx_runtime.JSX.Element | null;
+declare function DragInteraction({ stiffness, showArrow, ...groupProps }: DragInteractionProps & Omit<ThreeElements['group'], 'ref'>): react_jsx_runtime.JSX.Element | null;
 
 /**
  * @license
@@ -767,33 +779,15 @@ declare function SceneLights({ intensity }: SceneLightsProps): null;
  * Declarative debug visualization component.
  * Renders wireframe geoms, site markers, joint axes, contact forces, COM markers, etc.
  */
-declare function Debug({ showGeoms, showSites, showJoints, showContacts, showCOM, showInertia, showTendons, }: DebugProps): react_jsx_runtime.JSX.Element | null;
+declare function Debug({ showGeoms, showSites, showJoints, showContacts, showCOM, showInertia, showTendons, ...groupProps }: DebugProps & Omit<ThreeElements['group'], 'ref'>): react_jsx_runtime.JSX.Element | null;
 
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- *
- * TendonRenderer — render tendons as tube geometries (spec 6.4)
- *
- * WASM fields used: model.ntendon, model.ten_wrapadr, model.ten_wrapnum
- * data.wrap_xpos, data.ten_wrapadr (runtime)
- *
- * Note: ten_rgba and ten_width are NOT available in mujoco-js 0.0.7.
- * Tendons use a default color and width.
- */
-declare function TendonRenderer(): react_jsx_runtime.JSX.Element | null;
+declare function TendonRenderer(props: Omit<ThreeElements['group'], 'ref'>): react_jsx_runtime.JSX.Element | null;
 
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- *
- * FlexRenderer — render deformable flex bodies (spec 6.4)
- */
 /**
  * Renders MuJoCo flex (deformable) bodies as dynamic meshes.
  * Vertices are updated every frame from flexvert_xpos.
  */
-declare function FlexRenderer(): react_jsx_runtime.JSX.Element | null;
+declare function FlexRenderer(props: Omit<ThreeElements['group'], 'ref'>): react_jsx_runtime.JSX.Element | null;
 
 /**
  * @license
@@ -1160,4 +1154,4 @@ interface CameraAnimationAPI {
  */
 declare function useCameraAnimation(): CameraAnimationAPI;
 
-export { type ActuatorInfo, type BodyInfo, type BodyStateResult, type CameraAnimationAPI, type ContactInfo, ContactListener, type ContactListenerProps, ContactMarkers, type ControllerComponent, type ControllerOptions, Debug, type DebugProps, DragInteraction, type DragInteractionProps, FlexRenderer, type GeomInfo, type IKSolveFn, type IkConfig, type IkContextValue, IkController, IkGizmo, type IkGizmoProps, type JointInfo, type JointStateResult, type KeyBinding, type KeyboardTeleopConfig, type ModelOptions, MujocoCanvas, type MujocoCanvasProps, type MujocoContact, type MujocoContactArray, type MujocoContextValue, type MujocoData, type MujocoModel, type MujocoModule, MujocoProvider, type MujocoSimAPI, MujocoSimProvider, type PhysicsConfig, type PhysicsStepCallback, type PolicyConfig, type RayHit, type SceneConfig, SceneLights, type SceneLightsProps, type SceneMarker, type SceneObject, SceneRenderer, SelectionHighlight, type SelectionHighlightProps, type SensorInfo, type SensorResult, type SiteInfo, type SitePositionResult, type StateSnapshot, TendonRenderer, type TrajectoryData, type TrajectoryFrame, TrajectoryPlayer, type TrajectoryPlayerProps, type XmlPatch, createController, findActuatorByName, findBodyByName, findGeomByName, findJointByName, findKeyframeByName, findSensorByName, findSiteByName, findTendonByName, getContact, getName, loadScene, useActuators, useAfterPhysicsStep, useBeforePhysicsStep, useBodyState, useCameraAnimation, useContactEvents, useContacts, useCtrl, useCtrlNoise, useGamepad, useGravityCompensation, useIk, useJointState, useKeyboardTeleop, useMujoco, useMujocoSim, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };
+export { type ActuatorInfo, type BodyInfo, type BodyStateResult, type CameraAnimationAPI, type ContactInfo, ContactListener, type ContactListenerProps, ContactMarkers, type ControllerComponent, type ControllerOptions, Debug, type DebugProps, DragInteraction, type DragInteractionProps, FlexRenderer, type GeomInfo, type IKSolveFn, type IkConfig, type IkContextValue, IkController, IkGizmo, type IkGizmoProps, type JointInfo, type JointStateResult, type KeyBinding, type KeyboardTeleopConfig, type ModelOptions, MujocoCanvas, type MujocoCanvasProps, type MujocoContact, type MujocoContactArray, type MujocoContextValue, type MujocoData, type MujocoModel, type MujocoModule, MujocoPhysics, type MujocoPhysicsProps, MujocoProvider, type MujocoSimAPI, MujocoSimProvider, type PhysicsConfig, type PhysicsStepCallback, type PolicyConfig, type RayHit, type SceneConfig, SceneLights, type SceneLightsProps, type SceneMarker, type SceneObject, SelectionHighlight, type SelectionHighlightProps, type SensorInfo, type SensorResult, type SiteInfo, type SitePositionResult, type StateSnapshot, TendonRenderer, type TrajectoryData, type TrajectoryFrame, TrajectoryPlayer, type TrajectoryPlayerProps, type XmlPatch, createController, findActuatorByName, findBodyByName, findGeomByName, findJointByName, findKeyframeByName, findSensorByName, findSiteByName, findTendonByName, getContact, getName, loadScene, useActuators, useAfterPhysicsStep, useBeforePhysicsStep, useBodyState, useCameraAnimation, useContactEvents, useContacts, useCtrl, useCtrlNoise, useGamepad, useGravityCompensation, useIk, useJointState, useKeyboardTeleop, useMujoco, useMujocoSim, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };