mujoco-react 6.0.1 → 7.0.1

package/README.md

@@ -4,9 +4,11 @@
 
 # mujoco-react
 
+> **Beta** — This library is under active development. The API may change between minor versions until 1.0.
+
 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)**
+**[Demo](https://mujoco-react-example.pages.dev)** | **[Docs](https://dadd.mintlify.app)** | **[Example Source](https://github.com/noah-wardlow/mujoco-react-example)** | **[llms.txt](https://dadd.mintlify.app/llms.txt)**
 
 ## Install
 
@@ -20,7 +22,7 @@ npm install mujoco-react three @react-three/fiber @react-three/drei
 import {
   MujocoProvider,
   MujocoCanvas,
-  IkController,
+  useIkController,
   IkGizmo,
 } from 'mujoco-react';
 import type { SceneConfig } from 'mujoco-react';
@@ -32,6 +34,18 @@ const config: SceneConfig = {
   homeJoints: [1.707, -1.754, 0.003, -2.702, 0.003, 0.951, 2.490],
 };
 
+function Scene() {
+  const ik = useIkController({ siteName: 'tcp', numJoints: 7 });
+  return (
+    <>
+      <OrbitControls enableDamping makeDefault />
+      {ik && <IkGizmo controller={ik} />}
+      <ambientLight intensity={0.7} />
+      <directionalLight position={[1, 2, 5]} intensity={1.2} castShadow />
+    </>
+  );
+}
+
 function App() {
   return (
     <MujocoProvider>
@@ -41,12 +55,7 @@ function App() {
         shadows
         style={{ width: '100%', height: '100vh' }}
       >
-        <OrbitControls enableDamping makeDefault />
-        <IkController config={{ siteName: 'tcp', numJoints: 7 }}>
-          <IkGizmo />
-        </IkController>
-        <ambientLight intensity={0.7} />
-        <directionalLight position={[1, 2, 5]} intensity={1.2} castShadow />
+        <Scene />
       </MujocoCanvas>
     </MujocoProvider>
   );
@@ -60,13 +69,14 @@ Inside `<MujocoCanvas>` or `<MujocoPhysics>`, `useMujoco()` gives you the simula
 ```tsx
 import { useMujoco } from 'mujoco-react';
 
-function StatusOverlay() {
-  const { status, api, mjModelRef, mjDataRef } = useMujoco();
+function MyComponent() {
+  const { isPending, isError, error, api, mjModelRef } = useMujoco();
 
-  if (status !== 'ready') return <span>Loading...</span>;
+  if (isPending) return <span>Loading...</span>;
+  if (isError) return <span>Error: {error}</span>;
 
   return (
-    <button onClick={() => api?.reset()}>
+    <button onClick={() => api.reset()}>
       Reset ({mjModelRef.current?.nq} joints)
     </button>
   );
@@ -122,17 +132,17 @@ export const MyController = createController<{ gain: number }>(
 ```
 <MujocoProvider>                           <MujocoProvider>
   <MujocoCanvas config={...}>               <Canvas shadows gl={...}>
-    <IkController config={..}>                <MujocoPhysics config={...}>
-      <IkGizmo />                               <MyController />
-    </IkController>                           </MujocoPhysics>
-    <MyController />                          <EffectComposer>...</EffectComposer>
-  </MujocoCanvas>                           </Canvas>
-</MujocoProvider>                         </MujocoProvider>
+    <Scene />                                  <MujocoPhysics config={...}>
+    <MyController />                             <MyController />
+  </MujocoCanvas>                              </MujocoPhysics>
+</MujocoProvider>                              <EffectComposer>...</EffectComposer>
+                                             </Canvas>
+                                           </MujocoProvider>
 ```
 
 ### Custom IK Solvers
 
-The built-in `<IkController>` uses Damped Least-Squares. Pass `ikSolveFn` to swap in your own solver (analytical, learned, etc.):
+The built-in `useIkController()` uses Damped Least-Squares. Pass `ikSolveFn` to swap in your own solver (analytical, learned, etc.):
 
 ```tsx
 import type { IKSolveFn } from 'mujoco-react';
@@ -141,19 +151,16 @@ 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>
+const ik = useIkController({ siteName: 'tcp', numJoints: 7, ikSolveFn: myIK });
 ```
 
-### `<IkController>`
+### `useIkController(config | null)`
 
-The library includes one controller for interactive end-effector control:
+Hook for interactive end-effector control. Pass `null` to disable IK (safe to call unconditionally):
 
 ```tsx
-<IkController config={{ siteName: 'tcp', numJoints: 7 }}>
-  <IkGizmo />
-</IkController>
+const ik = useIkController({ siteName: 'tcp', numJoints: 7 });
+return ik ? <IkGizmo controller={ik} /> : null;
 ```
 
 | Config | Type | Default | Description |
@@ -164,17 +171,9 @@ The library includes one controller for interactive end-effector control:
 | `damping` | `number` | `0.01` | DLS damping |
 | `maxIterations` | `number` | `50` | Max solver iterations |
 
-Access IK state from inside `<IkController>` with `useIk()`:
+Returns `IkContextValue | null` with methods like `setIkEnabled`, `moveTarget`, `syncTargetToSite`, `solveIK`, and `getGizmoStats`.
 
-```tsx
-const { setIkEnabled, moveTarget, solveIK } = useIk();
-```
-
-Pass `{ optional: true }` for components that may or may not be inside an `<IkController>`:
-
-```tsx
-const ikCtx = useIk({ optional: true });
-```
+Pass the returned value to `<IkGizmo controller={ik} />` or to your own controller as a prop.
 
 ## Loading Models
 
@@ -289,13 +288,46 @@ Physics provider for use inside your own R3F `<Canvas>`. Same physics props as `
 | `paused` | `boolean` | Declarative pause |
 | `speed` | `number` | Simulation speed multiplier |
 
+### `<Body />`
+
+Declaratively add physics bodies to the simulation as JSX. Bodies are injected into the MJCF XML before model compilation.
+
+```tsx
+<Body name="cube" type="box" size={[0.05, 0.05, 0.05]}
+      position={[0.5, 0, 0.05]} rgba={[1, 0, 0, 1]}
+      mass={0.1} freejoint />
+
+// With custom Three.js visuals
+<Body name="ball" type="sphere" size={[0.03, 0, 0]}
+      position={[0, 0.3, 0.1]} mass={0.5} freejoint>
+  <mesh>
+    <sphereGeometry args={[0.03]} />
+    <meshPhysicalMaterial color="gold" metalness={0.8} />
+  </mesh>
+</Body>
+```
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `name` | `string` | **required** | Unique body name |
+| `type` | `'box' \| 'sphere' \| 'cylinder'` | **required** | Geom type |
+| `size` | `[number, number, number]` | **required** | Geom size |
+| `position` | `[number, number, number]` | `[0,0,0]` | Initial position |
+| `rgba` | `[number, number, number, number]` | `[0.5,0.5,0.5,1]` | Color (ignored with children) |
+| `mass` | `number?` | -- | Body mass in kg |
+| `freejoint` | `boolean?` | -- | Add freejoint for free movement |
+| `friction` | `string?` | -- | MuJoCo friction params |
+| `condim` | `number?` | -- | Contact dimensionality (4-6 for grasping) |
+| `children` | `ReactNode?` | -- | Custom Three.js visuals |
+
 ### `<IkGizmo />`
 
-drei PivotControls gizmo that tracks a MuJoCo site and drives IK on drag. Must be inside `<IkController>`.
+drei PivotControls gizmo that tracks a MuJoCo site and drives IK on drag. Requires a `controller` from `useIkController()`.
 
 | Prop | Type | Default | Description |
 |------|------|---------|-------------|
-| `siteName` | `string?` | IkController's site | MuJoCo site to track |
+| `controller` | `IkContextValue` | **required** | Controller from `useIkController()` |
+| `siteName` | `string?` | controller's site | MuJoCo site to track |
 | `scale` | `number?` | `0.18` | Gizmo handle scale |
 | `onDrag` | `(pos, quat) => void` | -- | Custom drag handler (disables auto-IK) |
 
@@ -373,10 +405,13 @@ Plays back recorded qpos trajectories with scrubbing.
 
 ### `useMujoco()`
 
-Access the simulation API and internal refs (must be inside `<MujocoCanvas>` or `<MujocoPhysics>`):
+Access the simulation API (must be inside `<MujocoCanvas>` or `<MujocoPhysics>`). Narrow on `isReady`, `isPending`, or `isError`:
 
 ```tsx
-const { api, status, mjModelRef, mjDataRef } = useMujoco();
+const sim = useMujoco();
+if (sim.isReady) {
+  sim.api.reset(); // fully typed
+}
 ```
 
 ### `useMujocoWasm()`
@@ -410,9 +445,9 @@ useBeforePhysicsStep((model, data) => {
 
 Run logic **after** `mj_step` each frame. Read results, compute rewards, log telemetry.
 
-### `useIk()` / `useIk({ optional: true })`
+### `useIkController(config | null)`
 
-Access IK controller state. `useIk()` throws if not inside `<IkController>`. Pass `{ optional: true }` to get `null` instead.
+Set up IK control for a MuJoCo site. Pass `null` to disable. Returns `IkContextValue | null`.
 
 ### `useCameraAnimation()`
 
@@ -579,7 +614,7 @@ useSceneLights(1.5);
 
 ## MujocoSimAPI
 
-The full API object available via `ref` or `useMujoco().api`:
+The full API object available via `ref` or `useMujoco()` (when `isReady`):
 
 ### Simulation Control
 
@@ -682,7 +717,7 @@ See [Click-to-Select](https://dadd.mintlify.app/guides/click-to-select) for the
 | Priority | Owner | Purpose |
 |----------|-------|---------|
 | -1 | MujocoSimProvider | beforeStep, mj_step, afterStep |
-| 0 (default) | SceneRenderer (internal), IkController, your code | Body mesh sync, IK, rendering |
+| 0 (default) | SceneRenderer (internal), useIkController, your code | Body mesh sync, IK, rendering |
 
 ## Roadmap
 

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode } from 'react';
 import { CanvasProps, ThreeElements } from '@react-three/fiber';
 import * as THREE from 'three';
-import * as react from 'react';
 
 /**
  * @license
@@ -254,6 +255,20 @@ interface IkConfig {
     /** 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;
@@ -374,6 +389,7 @@ interface DebugProps {
     showTendons?: boolean;
 }
 interface IkGizmoProps {
+    controller: IkContextValue;
     siteName?: string;
     scale?: number;
     onDrag?: (position: THREE.Vector3, quaternion: THREE.Quaternion) => void;
@@ -398,6 +414,20 @@ interface ContactListenerProps {
     onContactEnter?: (info: ContactInfo) => void;
     onContactExit?: (info: ContactInfo) => void;
 }
+interface BodyProps {
+    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;
+    children?: ReactNode;
+}
 interface MujocoSimAPI {
     readonly status: 'loading' | 'ready' | 'error';
     readonly config: SceneConfig;
@@ -445,8 +475,8 @@ interface MujocoSimAPI {
     setBodyMass(name: string, mass: number): void;
     setGeomFriction(name: string, friction: [number, number, number]): void;
     setGeomSize(name: string, size: [number, number, number]): void;
-    readonly mjModelRef: React.RefObject<MujocoModel | null>;
-    readonly mjDataRef: React.RefObject<MujocoData | null>;
+    readonly mjModelRef: React__default.RefObject<MujocoModel | null>;
+    readonly mjDataRef: React__default.RefObject<MujocoData | null>;
 }
 type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
     config: SceneConfig;
@@ -461,8 +491,8 @@ type MujocoCanvasProps = Omit<CanvasProps, 'onError'> & {
     speed?: number;
 };
 interface SitePositionResult {
-    position: React.RefObject<THREE.Vector3>;
-    quaternion: React.RefObject<THREE.Quaternion>;
+    position: React__default.RefObject<THREE.Vector3>;
+    quaternion: React__default.RefObject<THREE.Quaternion>;
 }
 interface MujocoContextValue {
     mujoco: MujocoModule | null;
@@ -470,18 +500,18 @@ interface MujocoContextValue {
     error: string | null;
 }
 interface SensorResult {
-    value: React.RefObject<Float64Array>;
+    value: React__default.RefObject<Float64Array>;
     size: number;
 }
 interface BodyStateResult {
-    position: React.RefObject<THREE.Vector3>;
-    quaternion: React.RefObject<THREE.Quaternion>;
-    linearVelocity: React.RefObject<THREE.Vector3>;
-    angularVelocity: React.RefObject<THREE.Vector3>;
+    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.RefObject<number | Float64Array>;
-    velocity: React.RefObject<number | Float64Array>;
+    position: React__default.RefObject<number | Float64Array>;
+    velocity: React__default.RefObject<number | Float64Array>;
 }
 
 /**
@@ -508,7 +538,7 @@ declare function MujocoProvider({ wasmUrl, timeout, children, onError }: MujocoP
  *
  * Forward ref exposes MujocoSimAPI (not the canvas element).
  */
-declare const MujocoCanvas: react.ForwardRefExoticComponent<Omit<MujocoCanvasProps, "ref"> & react.RefAttributes<MujocoSimAPI>>;
+declare const MujocoCanvas: React$1.ForwardRefExoticComponent<Omit<MujocoCanvasProps, "ref"> & React$1.RefAttributes<MujocoSimAPI>>;
 
 interface MujocoPhysicsProps {
     /** Scene/robot configuration. */
@@ -552,24 +582,37 @@ interface MujocoPhysicsProps {
  *
  * Forward ref exposes MujocoSimAPI.
  */
-declare const MujocoPhysics: react.ForwardRefExoticComponent<MujocoPhysicsProps & react.RefAttributes<MujocoSimAPI>>;
+declare const MujocoPhysics: React$1.ForwardRefExoticComponent<MujocoPhysicsProps & React$1.RefAttributes<MujocoSimAPI>>;
 
-interface MujocoSimContextValue {
+type UseMujocoResult = {
+    status: 'loading';
+    isPending: true;
+    isReady: false;
+    isError: false;
+    error: null;
+    api: null;
+    mjModelRef: null;
+    mjDataRef: null;
+} | {
+    status: 'error';
+    isPending: false;
+    isReady: false;
+    isError: true;
+    error: string;
+    api: null;
+    mjModelRef: null;
+    mjDataRef: null;
+} | {
+    status: 'ready';
+    isPending: false;
+    isReady: true;
+    isError: false;
+    error: null;
     api: MujocoSimAPI;
     mjModelRef: React.RefObject<MujocoModel | null>;
     mjDataRef: React.RefObject<MujocoData | null>;
-    mujocoRef: React.RefObject<MujocoModule>;
-    configRef: React.RefObject<SceneConfig>;
-    pausedRef: React.RefObject<boolean>;
-    speedRef: React.RefObject<number>;
-    substepsRef: React.RefObject<number>;
-    onSelectionRef: React.RefObject<((bodyId: number, name: string) => void) | undefined>;
-    beforeStepCallbacks: React.RefObject<Set<PhysicsStepCallback>>;
-    afterStepCallbacks: React.RefObject<Set<PhysicsStepCallback>>;
-    resetCallbacks: React.RefObject<Set<() => void>>;
-    status: 'loading' | 'ready' | 'error';
-}
-declare function useMujoco(): MujocoSimContextValue;
+};
+declare function useMujoco(): UseMujocoResult;
 declare function useBeforePhysicsStep(callback: PhysicsStepCallback): void;
 declare function useAfterPhysicsStep(callback: PhysicsStepCallback): void;
 interface MujocoSimProviderProps {
@@ -642,8 +685,6 @@ declare function loadScene(mujoco: MujocoModule, config: SceneConfig, onProgress
 /**
  * @license
  * SPDX-License-Identifier: Apache-2.0
- *
- * createController — typed factory for BYOC (Bring Your Own Controller) plugins.
  */
 interface ControllerOptions<TConfig> {
     /** Unique name for this controller (used as displayName). */
@@ -686,47 +727,37 @@ declare function createController<TConfig>(options: ControllerOptions<TConfig>,
     children?: React.ReactNode;
 }>): ControllerComponent<TConfig>;
 
-declare const IkController: ControllerComponent<IkConfig>;
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+declare const useIkController: (config: IkConfig | null) => IkContextValue | null;
 
-interface IkContextValue {
-    ikEnabledRef: React.RefObject<boolean>;
-    ikCalculatingRef: React.RefObject<boolean>;
-    ikTargetRef: React.RefObject<THREE.Group>;
-    siteIdRef: React.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;
-}
 /**
- * Access the IK controller context.
+ * Declarative physics body component. Registers a body definition in the
+ * provider-level registry so it gets injected into the MJCF XML at load time.
  *
- * - `useIk()` — throws if no `<IkController>` ancestor (use inside `<IkController>`)
- * - `useIk({ optional: true })` — returns `null` if no ancestor (use in components
- *   that optionally interact with IK, e.g. keyboard controllers that disable IK)
- */
-declare function useIk(): IkContextValue;
-declare function useIk(options: {
-    optional: true;
-}): IkContextValue | null;
+ * Bodies present at initial mount cause zero extra reloads (useLayoutEffect
+ * runs before the provider's loadScene useEffect). Bodies added/removed after
+ * the initial load trigger a debounced scene reload.
+ */
+declare function Body({ name, type, size, position, rgba, mass, freejoint, friction, solref, solimp, condim, children, }: BodyProps): react_jsx_runtime.JSX.Element | null;
 
 /**
  * IkGizmo — drei PivotControls that tracks a MuJoCo site.
  *
- * Must be rendered inside an `<IkController>`.
+ * Requires a `controller` from `useIkController()`.
  *
  * Props:
- * - `siteName` — MuJoCo site to track. Defaults to the IkController's configured site.
+ * - `controller` — IkContextValue from `useIkController()`.
+ * - `siteName` — MuJoCo site to track. Defaults to the controller's configured site.
  * - `scale` — Gizmo handle scale. Default: 0.18.
  * - `onDrag` — Custom drag callback `(pos, quat) => void`.
  *   When omitted, dragging enables IK and writes to the IK target.
  *   When provided, the consumer handles what happens during drag.
  */
-declare function IkGizmo({ siteName, scale, onDrag }: IkGizmoProps): react_jsx_runtime.JSX.Element | null;
+declare function IkGizmo({ controller, siteName, scale, onDrag }: IkGizmoProps): react_jsx_runtime.JSX.Element | null;
 
 interface ContactMarkersProps {
     /** Maximum contacts to render. Default: 100. */
@@ -1164,4 +1195,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, MujocoPhysics, type MujocoPhysicsProps, MujocoProvider, type MujocoSimAPI, MujocoSimProvider, type PhysicsConfig, type PhysicsStepCallback, type PolicyConfig, type RayHit, type SceneConfig, SceneLights, type SceneLightsProps, type SceneMarker, type SceneObject, 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, useBodyMeshes, useBodyState, useCameraAnimation, useContactEvents, useContacts, useCtrl, useCtrlNoise, useGamepad, useGravityCompensation, useIk, useJointState, useKeyboardTeleop, useMujoco, useMujocoWasm, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };
+export { type ActuatorInfo, Body, type BodyInfo, type BodyProps, 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, 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, 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, useBodyMeshes, useBodyState, useCameraAnimation, useContactEvents, useContacts, useCtrl, useCtrlNoise, useGamepad, useGravityCompensation, useIkController, useJointState, useKeyboardTeleop, useMujoco, useMujocoWasm, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };