mujoco-react 9.1.0 → 9.3.0

package/dist/index.js

@@ -1,10 +1,11 @@
-export { ScenarioLighting, SplatEnvironment, VisualScenarioEffects, createPairedSplatEnvironment, createSparkSplatViewerUrl, createSplatEnvironmentUserData, getScenarioBackground, getScenarioCameraPosition, useSplatEnvironment, useVisualScenarioEffects, withSplatEnvironment } from './chunk-33CV6HSV.js';
+import { withContacts, getContact } from './chunk-T3GVZJ4F.js';
+export { RobotActuators, RobotBodies, RobotCameras, RobotGeoms, RobotJoints, RobotKeyframes, RobotResources, RobotSensors, RobotSites, ScenarioLighting, SplatEnvironment, SplatEnvironmentReadinessStatus, VisualScenarioEffects, createPairedSplatEnvironment, createSparkSplatViewerUrl, createSplatEnvironmentUserData, getContact, getScenarioBackground, getScenarioCameraPosition, getSplatEnvironmentReadiness, registerRobotResources, useSplatEnvironment, useSplatSceneConfig, useVisualScenarioEffects, withSplatEnvironment } from './chunk-T3GVZJ4F.js';
 import loadMujoco from '@mujoco/mujoco';
 import defaultMujocoWasmUrl from '@mujoco/mujoco/mujoco.wasm?url';
 import { createContext, forwardRef, useEffect, useContext, useState, useRef, useCallback, useMemo, useLayoutEffect } from 'react';
 import { jsx, jsxs } from 'react/jsx-runtime';
 import { Canvas, useThree, useFrame } from '@react-three/fiber';
-import * as THREE11 from 'three';
+import * as THREE12 from 'three';
 import { PivotControls } from '@react-three/drei';
 
 var MujocoContext = createContext({
@@ -104,90 +105,16 @@ function MujocoProvider({
     }
   );
 }
-
-// src/types.ts
-var runtimeRobotResources = {};
-var REGISTER_RESOURCE_KEYS = ["actuators", "sensors", "bodies", "joints", "sites", "geoms", "keyframes"];
-function createEmptyRuntimeResources() {
-  return {
-    actuators: {},
-    sensors: {},
-    bodies: {},
-    joints: {},
-    sites: {},
-    geoms: {},
-    keyframes: {}
-  };
-}
-function registerRobotResources(resources) {
-  for (const [robot, robotResources] of Object.entries(resources)) {
-    const existing = runtimeRobotResources[robot] ?? createEmptyRuntimeResources();
-    for (const key of REGISTER_RESOURCE_KEYS) {
-      existing[key] = { ...existing[key], ...robotResources[key] ?? {} };
-    }
-    runtimeRobotResources[robot] = existing;
-  }
-}
-function createResourceCategory(key) {
-  return new Proxy({}, {
-    get(_target, robot) {
-      if (typeof robot !== "string") return void 0;
-      return runtimeRobotResources[robot]?.[key] ?? {};
-    },
-    ownKeys() {
-      return Reflect.ownKeys(runtimeRobotResources);
-    },
-    getOwnPropertyDescriptor(_target, robot) {
-      if (typeof robot !== "string" || !(robot in runtimeRobotResources)) return void 0;
-      return { enumerable: true, configurable: true };
-    }
-  });
-}
-var RobotResources = new Proxy(runtimeRobotResources, {
-  get(target, robot) {
-    if (typeof robot !== "string") return void 0;
-    return target[robot] ?? createEmptyRuntimeResources();
-  },
-  ownKeys(target) {
-    return Reflect.ownKeys(target);
-  },
-  getOwnPropertyDescriptor(target, robot) {
-    if (typeof robot !== "string" || !(robot in target)) return void 0;
-    return { enumerable: true, configurable: true };
-  }
-});
-var RobotActuators = createResourceCategory("actuators");
-var RobotSensors = createResourceCategory("sensors");
-var RobotBodies = createResourceCategory("bodies");
-var RobotJoints = createResourceCategory("joints");
-var RobotSites = createResourceCategory("sites");
-var RobotGeoms = createResourceCategory("geoms");
-var RobotKeyframes = createResourceCategory("keyframes");
-function getContact(contacts, i) {
-  try {
-    return contacts.get(i);
-  } catch {
-    return void 0;
-  }
-}
-function withContacts(data, read) {
-  const contacts = data.contact;
-  try {
-    return read(contacts);
-  } finally {
-    contacts.delete?.();
-  }
-}
-var CapsuleGeometry = class extends THREE11.BufferGeometry {
+var CapsuleGeometry = class extends THREE12.BufferGeometry {
   parameters;
   constructor(radius = 1, length = 1, capSegments = 4, radialSegments = 8) {
     super();
     this.type = "CapsuleGeometry";
     this.parameters = { radius, length, capSegments, radialSegments };
-    const path = new THREE11.Path();
+    const path = new THREE12.Path();
     path.absarc(0, -length / 2, radius, Math.PI * 1.5, 0, false);
     path.absarc(0, length / 2, radius, 0, Math.PI * 0.5, false);
-    const latheGeometry = new THREE11.LatheGeometry(path.getPoints(capSegments), radialSegments);
+    const latheGeometry = new THREE12.LatheGeometry(path.getPoints(capSegments), radialSegments);
     const self = this;
     self.setIndex(latheGeometry.getIndex());
     self.setAttribute("position", latheGeometry.getAttribute("position"));
@@ -195,27 +122,27 @@ var CapsuleGeometry = class extends THREE11.BufferGeometry {
     self.setAttribute("uv", latheGeometry.getAttribute("uv"));
   }
 };
-var Reflector = class extends THREE11.Mesh {
+var Reflector = class extends THREE12.Mesh {
   isReflector = true;
   camera;
-  reflectorPlane = new THREE11.Plane();
-  normal = new THREE11.Vector3();
-  reflectorWorldPosition = new THREE11.Vector3();
-  cameraWorldPosition = new THREE11.Vector3();
-  rotationMatrix = new THREE11.Matrix4();
-  lookAtPosition = new THREE11.Vector3(0, 0, -1);
-  clipPlane = new THREE11.Vector4();
-  view = new THREE11.Vector3();
-  target = new THREE11.Vector3();
-  q = new THREE11.Vector4();
-  textureMatrix = new THREE11.Matrix4();
+  reflectorPlane = new THREE12.Plane();
+  normal = new THREE12.Vector3();
+  reflectorWorldPosition = new THREE12.Vector3();
+  cameraWorldPosition = new THREE12.Vector3();
+  rotationMatrix = new THREE12.Matrix4();
+  lookAtPosition = new THREE12.Vector3(0, 0, -1);
+  clipPlane = new THREE12.Vector4();
+  view = new THREE12.Vector3();
+  target = new THREE12.Vector3();
+  q = new THREE12.Vector4();
+  textureMatrix = new THREE12.Matrix4();
   virtualCamera;
   renderTarget;
   constructor(geometry, options = {}) {
     super(geometry);
     this.type = "Reflector";
-    this.camera = new THREE11.PerspectiveCamera();
-    const color = options.color !== void 0 ? new THREE11.Color(options.color) : new THREE11.Color(8355711);
+    this.camera = new THREE12.PerspectiveCamera();
+    const color = options.color !== void 0 ? new THREE12.Color(options.color) : new THREE12.Color(8355711);
     const textureWidth = options.textureWidth || 512;
     const textureHeight = options.textureHeight || 512;
     const clipBias = options.clipBias || 0;
@@ -223,11 +150,11 @@ var Reflector = class extends THREE11.Mesh {
     const blendTexture = options.texture || void 0;
     const mixStrength = options.mixStrength !== void 0 ? options.mixStrength : 0.25;
     this.virtualCamera = this.camera;
-    this.renderTarget = new THREE11.WebGLRenderTarget(textureWidth, textureHeight, {
+    this.renderTarget = new THREE12.WebGLRenderTarget(textureWidth, textureHeight, {
       samples: multisample,
-      type: THREE11.HalfFloatType
+      type: THREE12.HalfFloatType
     });
-    this.material = new THREE11.MeshPhysicalMaterial({
+    this.material = new THREE12.MeshPhysicalMaterial({
       map: blendTexture,
       color,
       roughness: 0.5,
@@ -353,7 +280,7 @@ var GeomBuilder = class {
     const pos = mjModel.geom_pos.subarray(g * 3, g * 3 + 3);
     const quat = mjModel.geom_quat.subarray(g * 4, g * 4 + 4);
     const matId = mjModel.geom_matid[g];
-    const color = new THREE11.Color(16777215);
+    const color = new THREE12.Color(16777215);
     let opacity = 1;
     if (matId >= 0) {
       const rgba = mjModel.mat_rgba.subarray(matId * 4, matId * 4 + 4);
@@ -368,16 +295,16 @@ var GeomBuilder = class {
     let geo = null;
     const getVal = (v) => v?.value ?? v;
     if (type === getVal(MG.mjGEOM_PLANE)) {
-      geo = new THREE11.PlaneGeometry(size[0] * 2 || 5, size[1] * 2 || 5);
+      geo = new THREE12.PlaneGeometry(size[0] * 2 || 5, size[1] * 2 || 5);
     } else if (type === getVal(MG.mjGEOM_SPHERE)) {
-      geo = new THREE11.SphereGeometry(size[0], 24, 24);
+      geo = new THREE12.SphereGeometry(size[0], 24, 24);
     } else if (type === getVal(MG.mjGEOM_CAPSULE)) {
       geo = new CapsuleGeometry(size[0], size[1] * 2, 24, 12);
       geo.rotateX(Math.PI / 2);
     } else if (type === getVal(MG.mjGEOM_BOX)) {
-      geo = new THREE11.BoxGeometry(size[0] * 2, size[1] * 2, size[2] * 2);
+      geo = new THREE12.BoxGeometry(size[0] * 2, size[1] * 2, size[2] * 2);
     } else if (type === getVal(MG.mjGEOM_CYLINDER)) {
-      geo = new THREE11.CylinderGeometry(size[0], size[0], size[1] * 2, 24);
+      geo = new THREE12.CylinderGeometry(size[0], size[0], size[1] * 2, 24);
       geo.rotateX(Math.PI / 2);
     } else if (type === getVal(MG.mjGEOM_MESH)) {
       const mId = mjModel.geom_dataid[g];
@@ -385,8 +312,8 @@ var GeomBuilder = class {
       const vNum = mjModel.mesh_vertnum[mId];
       const fAdr = mjModel.mesh_faceadr[mId];
       const fNum = mjModel.mesh_facenum[mId];
-      geo = new THREE11.BufferGeometry();
-      geo.setAttribute("position", new THREE11.Float32BufferAttribute(mjModel.mesh_vert.subarray(vAdr * 3, (vAdr + vNum) * 3), 3));
+      geo = new THREE12.BufferGeometry();
+      geo.setAttribute("position", new THREE12.Float32BufferAttribute(mjModel.mesh_vert.subarray(vAdr * 3, (vAdr + vNum) * 3), 3));
       geo.setIndex(Array.from(mjModel.mesh_face.subarray(fAdr * 3, (fAdr + fNum) * 3)));
       geo.computeVertexNormals();
     }
@@ -401,7 +328,7 @@ var GeomBuilder = class {
           mixStrength: 0.25
         });
       } else {
-        mesh = new THREE11.Mesh(geo, new THREE11.MeshStandardMaterial({
+        mesh = new THREE12.Mesh(geo, new THREE12.MeshStandardMaterial({
           color,
           transparent: opacity < 1,
           opacity,
@@ -480,6 +407,15 @@ function findSensorByName(mjModel, name) {
   }
   return -1;
 }
+function findCameraByName(mjModel, name) {
+  const ncam = mjModel.ncam ?? 0;
+  const addresses = mjModel.name_camadr;
+  if (!addresses) return -1;
+  for (let i = 0; i < ncam; i++) {
+    if (getName(mjModel, addresses[i]) === name) return i;
+  }
+  return -1;
+}
 function findTendonByName(mjModel, name) {
   for (let i = 0; i < (mjModel.ntendon ?? 0); i++) {
     if (getName(mjModel, mjModel.name_tendonadr[i]) === name) return i;
@@ -1206,7 +1142,7 @@ function SceneRenderer(props) {
     }
     const refs = [];
     for (let i = 0; i < model.nbody; i++) {
-      const bodyGroup = new THREE11.Group();
+      const bodyGroup = new THREE12.Group();
       bodyGroup.userData.bodyID = i;
       const bodyName = getName(model, model.name_bodyadr[i]);
       if (!hiddenBodiesRef.current.has(bodyName)) {
@@ -1235,9 +1171,9 @@ function SceneRenderer(props) {
         const alpha = interpolation.alpha;
         const i3 = i * 3;
         ref.position.set(
-          THREE11.MathUtils.lerp(interpolation.previousXpos[i3], interpolation.currentXpos[i3], alpha),
-          THREE11.MathUtils.lerp(interpolation.previousXpos[i3 + 1], interpolation.currentXpos[i3 + 1], alpha),
-          THREE11.MathUtils.lerp(interpolation.previousXpos[i3 + 2], interpolation.currentXpos[i3 + 2], alpha)
+          THREE12.MathUtils.lerp(interpolation.previousXpos[i3], interpolation.currentXpos[i3], alpha),
+          THREE12.MathUtils.lerp(interpolation.previousXpos[i3 + 1], interpolation.currentXpos[i3 + 1], alpha),
+          THREE12.MathUtils.lerp(interpolation.previousXpos[i3 + 2], interpolation.currentXpos[i3 + 2], alpha)
         );
         const i4 = i * 4;
         _previousQuat.set(
@@ -1292,8 +1228,8 @@ function SceneRenderer(props) {
     }
   );
 }
-var _previousQuat = new THREE11.Quaternion();
-var _currentQuat = new THREE11.Quaternion();
+var _previousQuat = new THREE12.Quaternion();
+var _currentQuat = new THREE12.Quaternion();
 function isTargetRef(target) {
   return Boolean(target && typeof target === "object" && "current" in target);
 }
@@ -1402,6 +1338,412 @@ function useFrameCapture(defaultOptions = {}) {
     reset
   };
 }
+function toVector3(value, fallback) {
+  if (!value) return fallback.clone();
+  return value instanceof THREE12.Vector3 ? value.clone() : new THREE12.Vector3(value[0], value[1], value[2]);
+}
+function applyCameraPose(camera, options, fallbackCamera) {
+  camera.position.copy(toVector3(options.position, fallbackCamera.position));
+  camera.up.copy(toVector3(options.up, fallbackCamera.up));
+  if (options.quaternion) {
+    if (options.quaternion instanceof THREE12.Quaternion) {
+      camera.quaternion.copy(options.quaternion);
+    } else {
+      camera.quaternion.set(
+        options.quaternion[0],
+        options.quaternion[1],
+        options.quaternion[2],
+        options.quaternion[3]
+      );
+    }
+  } else if (options.lookAt) {
+    camera.lookAt(toVector3(options.lookAt, new THREE12.Vector3()));
+  } else {
+    camera.quaternion.copy(fallbackCamera.quaternion);
+  }
+  camera.updateMatrixWorld();
+}
+function createCaptureCamera(options, fallbackCamera, width, height) {
+  const camera = options.camera ? options.camera.clone() : fallbackCamera instanceof THREE12.PerspectiveCamera ? fallbackCamera.clone() : new THREE12.PerspectiveCamera(45, width / height, 0.01, 100);
+  if (camera instanceof THREE12.PerspectiveCamera) {
+    camera.aspect = width / height;
+    camera.fov = options.fov ?? camera.fov;
+    camera.near = options.near ?? camera.near;
+    camera.far = options.far ?? camera.far;
+    camera.updateProjectionMatrix();
+  }
+  applyCameraPose(camera, options, fallbackCamera);
+  return camera;
+}
+function getCaptureDimensions(renderer, options) {
+  const width = Math.max(
+    1,
+    Math.floor(options.width ?? renderer.domElement.width)
+  );
+  const height = Math.max(
+    1,
+    Math.floor(options.height ?? renderer.domElement.height)
+  );
+  return { width, height };
+}
+function prepareCaptureCamera(camera, options, fallbackCamera, width, height) {
+  if (options.camera) {
+    camera.copy(options.camera);
+  }
+  if (camera instanceof THREE12.PerspectiveCamera) {
+    camera.aspect = width / height;
+    camera.fov = options.fov ?? camera.fov;
+    camera.near = options.near ?? camera.near;
+    camera.far = options.far ?? camera.far;
+    camera.updateProjectionMatrix();
+  }
+  applyCameraPose(camera, options, fallbackCamera);
+}
+function readRenderTargetToCanvas(renderer, target, canvas, context, pixels, imageData, width, height) {
+  renderer.readRenderTargetPixels(target, 0, 0, width, height, pixels);
+  const rowBytes = width * 4;
+  for (let y = 0; y < height; y += 1) {
+    const sourceStart = (height - y - 1) * rowBytes;
+    const targetStart = y * rowBytes;
+    imageData.data.set(
+      pixels.subarray(sourceStart, sourceStart + rowBytes),
+      targetStart
+    );
+  }
+  context.putImageData(imageData, 0, 0);
+  return canvas;
+}
+function getCameraFrameCaptureSource(options) {
+  if (options.source) return options.source;
+  if (options.cameraName) {
+    return { kind: "mujoco-camera", cameraName: options.cameraName };
+  }
+  if (options.siteName) {
+    return { kind: "mujoco-site", siteName: options.siteName };
+  }
+  if (options.bodyName) {
+    return { kind: "mujoco-body", bodyName: options.bodyName };
+  }
+  if (options.camera) return { kind: "custom-camera" };
+  if (options.position || options.lookAt || options.quaternion) {
+    return { kind: "explicit-pose" };
+  }
+  return { kind: "fallback-camera" };
+}
+function createCameraFrameCaptureSession(renderer, scene, fallbackCamera, options = {}) {
+  const { width, height } = getCaptureDimensions(renderer, options);
+  const camera = createCaptureCamera(options, fallbackCamera, width, height);
+  const target = new THREE12.WebGLRenderTarget(width, height, {
+    format: THREE12.RGBAFormat,
+    type: THREE12.UnsignedByteType
+  });
+  const canvas = document.createElement("canvas");
+  canvas.width = width;
+  canvas.height = height;
+  const context = canvas.getContext("2d");
+  if (!context) {
+    target.dispose();
+    throw new Error("Unable to create a 2D canvas for camera frame capture.");
+  }
+  const drawContext = context;
+  const pixels = new Uint8Array(width * height * 4);
+  const imageData = drawContext.createImageData(width, height);
+  function capture(nextOptions = {}) {
+    const captureOptions = { ...options, ...nextOptions };
+    const nextDimensions = getCaptureDimensions(renderer, captureOptions);
+    if (nextDimensions.width !== width || nextDimensions.height !== height) {
+      throw new Error(
+        "Camera frame capture sessions require stable width and height."
+      );
+    }
+    prepareCaptureCamera(
+      camera,
+      captureOptions,
+      fallbackCamera,
+      width,
+      height
+    );
+    const previousTarget = renderer.getRenderTarget();
+    const previousXrEnabled = renderer.xr.enabled;
+    scene.updateMatrixWorld(true);
+    try {
+      renderer.xr.enabled = false;
+      renderer.setRenderTarget(target);
+      renderer.clear();
+      renderer.render(scene, camera);
+      readRenderTargetToCanvas(
+        renderer,
+        target,
+        canvas,
+        drawContext,
+        pixels,
+        imageData,
+        width,
+        height
+      );
+      return {
+        canvas,
+        camera,
+        width,
+        height,
+        source: getCameraFrameCaptureSource(captureOptions)
+      };
+    } finally {
+      renderer.setRenderTarget(previousTarget);
+      renderer.xr.enabled = previousXrEnabled;
+    }
+  }
+  return {
+    width,
+    height,
+    capture,
+    captureDataUrl(nextOptions = {}) {
+      const type = nextOptions.type ?? options.type ?? "image/png";
+      const result = capture(nextOptions);
+      return {
+        ...result,
+        dataUrl: result.canvas.toDataURL(
+          type,
+          nextOptions.quality ?? options.quality
+        ),
+        type
+      };
+    },
+    async captureBlob(nextOptions = {}) {
+      const type = nextOptions.type ?? options.type ?? "image/png";
+      const result = capture(nextOptions);
+      const blob = await new Promise((resolve, reject) => {
+        result.canvas.toBlob(
+          (nextBlob) => {
+            if (nextBlob) resolve(nextBlob);
+            else reject(new Error("Camera frame capture did not produce a Blob."));
+          },
+          type,
+          nextOptions.quality ?? options.quality
+        );
+      });
+      return { ...result, blob, type };
+    },
+    dispose() {
+      target.dispose();
+    }
+  };
+}
+function renderCameraFrameToCanvas(renderer, scene, fallbackCamera, options = {}) {
+  const session = createCameraFrameCaptureSession(
+    renderer,
+    scene,
+    fallbackCamera,
+    options
+  );
+  try {
+    return session.capture();
+  } finally {
+    session.dispose();
+  }
+}
+async function captureCameraFrame(renderer, scene, fallbackCamera, options = {}) {
+  const type = options.type ?? "image/png";
+  const result = renderCameraFrameToCanvas(
+    renderer,
+    scene,
+    fallbackCamera,
+    options
+  );
+  return {
+    ...result,
+    dataUrl: result.canvas.toDataURL(type, options.quality),
+    type
+  };
+}
+async function captureCameraFrameBlob(renderer, scene, fallbackCamera, options = {}) {
+  const type = options.type ?? "image/png";
+  const result = renderCameraFrameToCanvas(
+    renderer,
+    scene,
+    fallbackCamera,
+    options
+  );
+  const blob = await new Promise((resolve, reject) => {
+    result.canvas.toBlob(
+      (nextBlob) => {
+        if (nextBlob) resolve(nextBlob);
+        else reject(new Error("Camera frame capture did not produce a Blob."));
+      },
+      type,
+      options.quality
+    );
+  });
+  return { ...result, blob, type };
+}
+
+// src/rendering/cameraFrameSource.ts
+var MountedCameraFrameSequenceReadinessStatus = {
+  Ready: "ready",
+  Partial: "partial",
+  Missing: "missing"
+};
+function getResourceName(resource) {
+  if (!resource) return null;
+  return typeof resource === "string" ? resource : resource.name ?? null;
+}
+function createNameSet(resources) {
+  return new Set(
+    (resources ?? []).map((resource) => getResourceName(resource)).filter((name) => Boolean(name))
+  );
+}
+function normalizeAliasCandidates(value) {
+  if (!value) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function countMountedSelectors(selector) {
+  return Number(Boolean(selector.cameraName)) + Number(Boolean(selector.siteName)) + Number(Boolean(selector.bodyName));
+}
+function getMountedCameraFrameCaptureSource(selector) {
+  if (countMountedSelectors(selector) !== 1) return null;
+  if (selector.cameraName) {
+    return { kind: "mujoco-camera", cameraName: selector.cameraName };
+  }
+  if (selector.siteName) {
+    return { kind: "mujoco-site", siteName: selector.siteName };
+  }
+  if (selector.bodyName) {
+    return { kind: "mujoco-body", bodyName: selector.bodyName };
+  }
+  return null;
+}
+function isMountedCameraFrameCaptureSource(source) {
+  return source.kind === "mujoco-camera" || source.kind === "mujoco-site" || source.kind === "mujoco-body";
+}
+function getCameraFrameCaptureSourceTarget(source) {
+  if (source.kind === "mujoco-camera") return source.cameraName;
+  if (source.kind === "mujoco-site") return source.siteName;
+  if (source.kind === "mujoco-body") return source.bodyName;
+  if (source.kind === "custom-camera") return "custom camera";
+  if (source.kind === "explicit-pose") return "explicit pose";
+  return "fallback camera";
+}
+function isSelectorMounted(selector, cameraNames, siteNames, bodyNames) {
+  if (countMountedSelectors(selector) !== 1) return false;
+  return (selector.cameraName ? cameraNames.has(selector.cameraName) : false) || (selector.siteName ? siteNames.has(selector.siteName) : false) || (selector.bodyName ? bodyNames.has(selector.bodyName) : false);
+}
+function resolveMountedCameraFrameSource(key, options) {
+  const cameraNames = createNameSet(options.cameras);
+  const siteNames = createNameSet(options.sites);
+  const bodyNames = createNameSet(options.bodies);
+  const directCandidates = [
+    { cameraName: key },
+    { siteName: key },
+    { bodyName: key }
+  ];
+  const aliasCandidates = normalizeAliasCandidates(options.aliases?.[key]);
+  const candidates = [...directCandidates, ...aliasCandidates];
+  for (const selector of candidates) {
+    if (!isSelectorMounted(selector, cameraNames, siteNames, bodyNames)) {
+      continue;
+    }
+    const source = getMountedCameraFrameCaptureSource(selector);
+    if (!source) continue;
+    return { key, selector, source };
+  }
+  if (options.allowAliasFallback) {
+    for (const selector of aliasCandidates) {
+      const source = getMountedCameraFrameCaptureSource(selector);
+      if (!source) continue;
+      return { key, selector, source };
+    }
+  }
+  return null;
+}
+function createMountedCameraFrameSequencePlan(cameraKeys, options) {
+  const cameras = [];
+  const resolved = {};
+  const missingKeys = [];
+  for (const key of cameraKeys) {
+    const mountedSource = resolveMountedCameraFrameSource(key, options);
+    if (!mountedSource) {
+      missingKeys.push(key);
+      continue;
+    }
+    resolved[key] = mountedSource;
+    cameras.push({
+      key,
+      ...options.defaults,
+      ...options.cameraOptions?.[key],
+      ...mountedSource.selector,
+      source: mountedSource.source
+    });
+  }
+  if (options.requireAll && missingKeys.length > 0) {
+    throw new Error(
+      `Unable to resolve mounted MuJoCo camera source${missingKeys.length === 1 ? "" : "s"} for ${missingKeys.join(", ")}.`
+    );
+  }
+  return {
+    cameraKeys: [...cameraKeys],
+    cameras,
+    resolved,
+    missingKeys
+  };
+}
+function createMountedCameraFrameSequenceReadiness(plan) {
+  const cameras = {};
+  const resolvedKeys = plan.cameraKeys.filter((key) => Boolean(plan.resolved[key]));
+  for (const key of plan.cameraKeys) {
+    const resolved = plan.resolved[key];
+    cameras[key] = resolved ? {
+      key,
+      ready: true,
+      selector: resolved.selector,
+      source: resolved.source,
+      message: `Camera stream "${key}" resolves to ${resolved.source.kind}:${getCameraFrameCaptureSourceTarget(resolved.source)}.`
+    } : {
+      key,
+      ready: false,
+      message: `Camera stream "${key}" does not resolve to a mounted MuJoCo camera, site, or body.`
+    };
+  }
+  const missingKeys = [...plan.missingKeys];
+  const ready = missingKeys.length === 0;
+  const status = ready ? MountedCameraFrameSequenceReadinessStatus.Ready : resolvedKeys.length > 0 ? MountedCameraFrameSequenceReadinessStatus.Partial : MountedCameraFrameSequenceReadinessStatus.Missing;
+  return {
+    ready,
+    status,
+    cameraKeys: [...plan.cameraKeys],
+    resolvedKeys,
+    missingKeys,
+    cameras,
+    message: ready ? `All ${plan.cameraKeys.length} requested camera stream${plan.cameraKeys.length === 1 ? "" : "s"} resolve to mounted MuJoCo sources.` : `Missing mounted MuJoCo source${missingKeys.length === 1 ? "" : "s"} for ${missingKeys.join(", ")}.`
+  };
+}
+function createMountedCameraFrameSequencePlanFromApi(api, cameraKeys, options = {}) {
+  return createMountedCameraFrameSequencePlan(cameraKeys, {
+    ...options,
+    cameras: api.getCameras(),
+    sites: api.getSites(),
+    bodies: api.getBodies()
+  });
+}
+async function recordMountedCameraFrameSequence(api, options) {
+  const { cameraKeys, ...restOptions } = options;
+  const requireAll = restOptions.requireAll ?? restOptions.requireMountedSources ?? true;
+  const plan = createMountedCameraFrameSequencePlanFromApi(
+    api,
+    cameraKeys,
+    { ...restOptions, requireAll }
+  );
+  const readiness = createMountedCameraFrameSequenceReadiness(plan);
+  const result = await api.recordCameraSequence({
+    ...restOptions,
+    cameras: plan.cameras,
+    requireMountedSources: restOptions.requireMountedSources ?? true
+  });
+  return {
+    ...result,
+    plan,
+    readiness
+  };
+}
 var JOINT_TYPE_NAMES2 = ["free", "ball", "slide", "hinge"];
 var GEOM_TYPE_NAMES = ["plane", "hfield", "sphere", "capsule", "ellipsoid", "cylinder", "box", "mesh"];
 var SENSOR_TYPE_NAMES = {
@@ -1477,8 +1819,79 @@ var _applyPoint = new Float64Array(3);
 var _rayPnt = new Float64Array(3);
 var _rayVec = new Float64Array(3);
 var _rayGeomId = new Int32Array(1);
-var _projRaycaster = new THREE11.Raycaster();
-var _projNdc = new THREE11.Vector2();
+var _projRaycaster = new THREE12.Raycaster();
+var _projNdc = new THREE12.Vector2();
+function waitForNextAnimationFrame2() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+}
+function throwIfCameraSequenceAborted(signal) {
+  if (!signal?.aborted) return;
+  if (typeof signal.reason === "object" && signal.reason instanceof Error) {
+    throw signal.reason;
+  }
+  throw new DOMException("Camera sequence recording was aborted.", "AbortError");
+}
+function vector3FromArray(values, offset) {
+  return [values[offset], values[offset + 1], values[offset + 2]];
+}
+function quaternionFromArray(values, offset) {
+  return [
+    values[offset],
+    values[offset + 1],
+    values[offset + 2],
+    values[offset + 3]
+  ];
+}
+function quaternionFromXmat(values, offset) {
+  const matrix = new THREE12.Matrix4();
+  matrix.set(
+    values[offset],
+    values[offset + 1],
+    values[offset + 2],
+    0,
+    values[offset + 3],
+    values[offset + 4],
+    values[offset + 5],
+    0,
+    values[offset + 6],
+    values[offset + 7],
+    values[offset + 8],
+    0,
+    0,
+    0,
+    0,
+    1
+  );
+  const quaternion = new THREE12.Quaternion().setFromRotationMatrix(matrix);
+  return [quaternion.x, quaternion.y, quaternion.z, quaternion.w];
+}
+function omitResolvedCameraSelectors(options) {
+  const { cameraName, siteName, bodyName, ...rest } = options;
+  return rest;
+}
+function countMountedCameraSelectors(options) {
+  return Number(Boolean(options.cameraName)) + Number(Boolean(options.siteName)) + Number(Boolean(options.bodyName));
+}
+function assertMatchingMountedCameraSource(key, requested, source) {
+  const selectorCount = countMountedCameraSelectors(requested);
+  if (selectorCount !== 1) {
+    throw new Error(
+      `Camera sequence stream "${key}" must provide exactly one mounted MuJoCo cameraName, siteName, or bodyName selector.`
+    );
+  }
+  if (!isMountedCameraFrameCaptureSource(source)) {
+    throw new Error(
+      `Camera sequence stream "${key}" resolved to ${source.kind}; use a MuJoCo-mounted camera, site, or body selector for sequence recording.`
+    );
+  }
+  if (requested.cameraName && (source.kind !== "mujoco-camera" || source.cameraName !== requested.cameraName) || requested.siteName && (source.kind !== "mujoco-site" || source.siteName !== requested.siteName) || requested.bodyName && (source.kind !== "mujoco-body" || source.bodyName !== requested.bodyName)) {
+    throw new Error(
+      `Camera sequence stream "${key}" resolved to ${source.kind}:${getCameraFrameCaptureSourceTarget(source)} instead of the requested mounted selector.`
+    );
+  }
+}
 var MujocoSimContext = createContext(null);
 function useMujocoContext() {
   const ctx = useContext(MujocoSimContext);
@@ -1563,7 +1976,7 @@ function MujocoSimProvider({
   interpolate,
   children
 }) {
-  const { gl, camera } = useThree();
+  const { gl, camera, scene } = useThree();
   const [status, setStatus] = useState("loading");
   const mjModelRef = useRef(null);
   const mjDataRef = useRef(null);
@@ -1598,6 +2011,9 @@ function MujocoSimProvider({
   useEffect(() => {
     configRef.current = config;
   }, [config]);
+  useEffect(() => {
+    mujocoRef.current = mujoco;
+  }, [mujoco]);
   useEffect(() => {
     pausedRef.current = paused ?? false;
   }, [paused]);
@@ -1645,6 +2061,7 @@ function MujocoSimProvider({
           result.mjData.delete();
           return;
         }
+        mujocoRef.current = mujoco;
         mjModelRef.current = result.mjModel;
         mjDataRef.current = result.mjData;
         physicsAccumulatorRef.current = 0;
@@ -1710,7 +2127,7 @@ function MujocoSimProvider({
     if (!interpolateRef.current) {
       if (stepsToRunRef.current > 0) {
         for (let s = 0; s < stepsToRunRef.current; s++) {
-          mujoco.mj_step(model, data);
+          mujocoRef.current.mj_step(model, data);
         }
         stepsToRunRef.current = 0;
       } else {
@@ -1719,7 +2136,7 @@ function MujocoSimProvider({
         const frameTime = clampedDelta * speedRef.current;
         while (data.time - startSimTime < frameTime) {
           for (let s = 0; s < numSubsteps; s++) {
-            mujoco.mj_step(model, data);
+            mujocoRef.current.mj_step(model, data);
           }
         }
       }
@@ -1727,7 +2144,7 @@ function MujocoSimProvider({
       ensureInterpolationBuffers(model);
       copyBodyPose(data, interpolationStateRef.current.previousXpos, interpolationStateRef.current.previousXquat);
       for (let s = 0; s < stepsToRunRef.current; s++) {
-        mujoco.mj_step(model, data);
+        mujocoRef.current.mj_step(model, data);
       }
       copyBodyPose(data, interpolationStateRef.current.currentXpos, interpolationStateRef.current.currentXquat);
       interpolationStateRef.current.alpha = 1;
@@ -1742,7 +2159,7 @@ function MujocoSimProvider({
       while (physicsAccumulatorRef.current >= stepDt) {
         copyBodyPose(data, interpolationStateRef.current.previousXpos, interpolationStateRef.current.previousXquat);
         for (let s = 0; s < numSubsteps; s++) {
-          mujoco.mj_step(model, data);
+          mujocoRef.current.mj_step(model, data);
         }
         copyBodyPose(data, interpolationStateRef.current.currentXpos, interpolationStateRef.current.currentXquat);
         physicsAccumulatorRef.current -= stepDt;
@@ -1781,7 +2198,7 @@ function MujocoSimProvider({
     const model = mjModelRef.current;
     const data = mjDataRef.current;
     if (!model || !data) return;
-    mujoco.mj_resetData(model, data);
+    mujocoRef.current.mj_resetData(model, data);
     const homeJoints = configRef.current.homeJoints;
     if (homeJoints) {
       const homeCount = Math.min(homeJoints.length, model.nu);
@@ -1794,7 +2211,7 @@ function MujocoSimProvider({
       }
     }
     configRef.current.onReset?.({ model, data });
-    mujoco.mj_forward(model, data);
+    mujocoRef.current.mj_forward(model, data);
     for (const cb of resetCallbacks.current) {
       cb();
     }
@@ -1812,6 +2229,27 @@ function MujocoSimProvider({
   const step = useCallback((n = 1) => {
     stepsToRunRef.current = n;
   }, []);
+  useCallback((steps = 1) => {
+    const model = mjModelRef.current;
+    const data = mjDataRef.current;
+    if (!model || !data) return false;
+    for (let stepIndex = 0; stepIndex < steps; stepIndex += 1) {
+      for (let i = 0; i < model.nv; i += 1) {
+        data.qfrc_applied[i] = 0;
+      }
+      for (const cb of beforeStepCallbacks.current) {
+        cb({ model, data });
+      }
+      mujocoRef.current.mj_step(model, data);
+      for (const cb of afterStepCallbacks.current) {
+        cb({ model, data });
+      }
+      onStepRef.current?.({ time: data.time, model, data });
+    }
+    physicsAccumulatorRef.current = 0;
+    interpolationStateRef.current.valid = false;
+    return true;
+  }, [mujoco]);
   const getTime = useCallback(() => {
     return mjDataRef.current?.time ?? 0;
   }, []);
@@ -1840,7 +2278,7 @@ function MujocoSimProvider({
     data.ctrl.set(snapshot.ctrl);
     if (snapshot.act.length > 0) data.act.set(snapshot.act);
     data.qfrc_applied.set(snapshot.qfrc_applied);
-    mujoco.mj_forward(model, data);
+    mujocoRef.current.mj_forward(model, data);
   }, [mujoco]);
   const setQpos = useCallback((values) => {
     const model = mjModelRef.current;
@@ -1848,7 +2286,7 @@ function MujocoSimProvider({
     if (!model || !data) return;
     const arr = values instanceof Float64Array ? values : new Float64Array(values);
     data.qpos.set(arr.subarray(0, Math.min(arr.length, model.nq)));
-    mujoco.mj_forward(model, data);
+    mujocoRef.current.mj_forward(model, data);
   }, [mujoco]);
   const setQvel = useCallback((values) => {
     const data = mjDataRef.current;
@@ -2083,6 +2521,88 @@ function MujocoSimProvider({
     }
     return result;
   }, []);
+  const getCameras = useCallback(() => {
+    const model = mjModelRef.current;
+    if (!model) return [];
+    const ncam = model.ncam ?? 0;
+    const nameAddresses = model.name_camadr;
+    if (!ncam || !nameAddresses) return [];
+    const result = [];
+    for (let i = 0; i < ncam; i += 1) {
+      const posOffset = i * 3;
+      const quatOffset = i * 4;
+      result.push({
+        id: i,
+        name: getName(model, nameAddresses[i]),
+        bodyId: model.cam_bodyid?.[i] ?? -1,
+        fov: model.cam_fovy?.[i] ?? null,
+        position: model.cam_pos ? vector3FromArray(model.cam_pos, posOffset) : null,
+        quaternion: model.cam_quat ? quaternionFromArray(model.cam_quat, quatOffset) : null
+      });
+    }
+    return result;
+  }, []);
+  const resolveCameraCaptureOptions = useCallback(
+    (options = {}) => {
+      const model = mjModelRef.current;
+      const data = mjDataRef.current;
+      if (!model || !data) {
+        return options;
+      }
+      const baseOptions = omitResolvedCameraSelectors(options);
+      if (options.cameraName) {
+        const cameraId = findCameraByName(model, options.cameraName);
+        if (cameraId < 0) {
+          throw new Error(`MuJoCo camera "${options.cameraName}" was not found.`);
+        }
+        const position = data.cam_xpos ? vector3FromArray(data.cam_xpos, cameraId * 3) : model.cam_pos ? vector3FromArray(model.cam_pos, cameraId * 3) : void 0;
+        const quaternion = data.cam_xmat ? quaternionFromXmat(data.cam_xmat, cameraId * 9) : model.cam_quat ? quaternionFromArray(model.cam_quat, cameraId * 4) : void 0;
+        if (!position || !quaternion) {
+          throw new Error(
+            `MuJoCo camera "${options.cameraName}" does not expose a capture pose.`
+          );
+        }
+        return {
+          ...baseOptions,
+          position,
+          quaternion,
+          fov: options.fov ?? model.cam_fovy?.[cameraId],
+          source: { kind: "mujoco-camera", cameraName: options.cameraName }
+        };
+      }
+      if (options.siteName) {
+        const siteId = findSiteByName(model, options.siteName);
+        if (siteId < 0) {
+          throw new Error(`MuJoCo site "${options.siteName}" was not found.`);
+        }
+        return {
+          ...baseOptions,
+          position: vector3FromArray(data.site_xpos, siteId * 3),
+          quaternion: quaternionFromXmat(data.site_xmat, siteId * 9),
+          source: { kind: "mujoco-site", siteName: options.siteName }
+        };
+      }
+      if (options.bodyName) {
+        const bodyId = findBodyByName(model, options.bodyName);
+        if (bodyId < 0) {
+          throw new Error(`MuJoCo body "${options.bodyName}" was not found.`);
+        }
+        if (!data.xmat) {
+          throw new Error(
+            `MuJoCo body "${options.bodyName}" does not expose world orientation data.`
+          );
+        }
+        return {
+          ...baseOptions,
+          position: vector3FromArray(data.xpos, bodyId * 3),
+          quaternion: quaternionFromXmat(data.xmat, bodyId * 9),
+          source: { kind: "mujoco-body", bodyName: options.bodyName }
+        };
+      }
+      return options;
+    },
+    []
+  );
   const getModelOption = useCallback(() => {
     const model = mjModelRef.current;
     if (!model?.opt) return { timestep: 2e-3, gravity: [0, 0, -9.81], integrator: 0 };
@@ -2122,7 +2642,7 @@ function MujocoSimProvider({
       const geomId = _rayGeomId[0];
       const bodyId = geomId >= 0 ? model.geom_bodyid[geomId] : -1;
       return {
-        point: new THREE11.Vector3(
+        point: new THREE12.Vector3(
           origin.x + dir.x * dist,
           origin.y + dir.y * dist,
           origin.z + dir.z * dist
@@ -2159,7 +2679,7 @@ function MujocoSimProvider({
       const qvelOffset = keyId * model.nv;
       for (let i = 0; i < model.nv; i++) data.qvel[i] = model.key_qvel[qvelOffset + i];
     }
-    mujoco.mj_forward(model, data);
+    mujocoRef.current.mj_forward(model, data);
     for (const cb of resetCallbacks.current) {
       cb();
     }
@@ -2268,6 +2788,190 @@ function MujocoSimProvider({
     },
     [gl]
   );
+  const captureCameraFrameApi = useCallback(
+    (options = {}) => {
+      return captureCameraFrame(
+        gl,
+        scene,
+        camera,
+        resolveCameraCaptureOptions(options)
+      );
+    },
+    [camera, gl, resolveCameraCaptureOptions, scene]
+  );
+  const captureCameraFrameBlobApi = useCallback(
+    (options = {}) => {
+      return captureCameraFrameBlob(
+        gl,
+        scene,
+        camera,
+        resolveCameraCaptureOptions(options)
+      );
+    },
+    [camera, gl, resolveCameraCaptureOptions, scene]
+  );
+  const recordCameraSequenceApi = useCallback(
+    async (options) => {
+      const frameCount = Math.max(0, Math.floor(options.frames));
+      const stepsPerFrame = Math.max(0, Math.floor(options.stepsPerFrame ?? 1));
+      const cameras = options.cameras;
+      const frames = [];
+      const cameraSummaries = {};
+      const wasPaused = pausedRef.current;
+      const retainFrames = options.retainFrames ?? true;
+      const requireMountedSources = options.requireMountedSources ?? true;
+      let recordedFrameCount = 0;
+      async function stepCameraSequence(frameIndex, steps) {
+        const model = mjModelRef.current;
+        const data = mjDataRef.current;
+        if (!model || !data) {
+          throw new Error("MuJoCo scene is not ready for camera sequence stepping.");
+        }
+        for (let stepIndex = 0; stepIndex < steps; stepIndex += 1) {
+          for (let i = 0; i < model.nv; i += 1) {
+            data.qfrc_applied[i] = 0;
+          }
+          await options.onBeforeStep?.({
+            frameIndex,
+            stepIndex,
+            time: data.time,
+            model,
+            data
+          });
+          for (const cb of beforeStepCallbacks.current) {
+            cb({ model, data });
+          }
+          mujocoRef.current.mj_step(model, data);
+          for (const cb of afterStepCallbacks.current) {
+            cb({ model, data });
+          }
+          onStepRef.current?.({ time: data.time, model, data });
+          await options.onAfterStep?.({
+            frameIndex,
+            stepIndex,
+            time: data.time,
+            model,
+            data
+          });
+        }
+        physicsAccumulatorRef.current = 0;
+        interpolationStateRef.current.valid = false;
+      }
+      if (frameCount === 0 || cameras.length === 0) {
+        return {
+          frames,
+          cameraKeys: cameras.map((sequenceCamera) => sequenceCamera.key),
+          cameraSummaries,
+          frameCount: 0
+        };
+      }
+      throwIfCameraSequenceAborted(options.signal);
+      for (let attempt = 0; attempt < 30; attempt += 1) {
+        if (mjModelRef.current && mjDataRef.current) break;
+        await waitForNextAnimationFrame2();
+        throwIfCameraSequenceAborted(options.signal);
+      }
+      if (!mjModelRef.current || !mjDataRef.current) {
+        throw new Error("MuJoCo scene is not ready for camera sequence recording.");
+      }
+      const captureSessions = cameras.map((sequenceCamera) => {
+        const { key, ...captureOptions } = sequenceCamera;
+        const initialCaptureOptions = resolveCameraCaptureOptions(captureOptions);
+        const mountedSource = initialCaptureOptions.source;
+        if (requireMountedSources) {
+          assertMatchingMountedCameraSource(
+            key,
+            captureOptions,
+            mountedSource ?? { kind: "fallback-camera" }
+          );
+        }
+        return {
+          key,
+          captureOptions,
+          mountedSource,
+          session: createCameraFrameCaptureSession(
+            gl,
+            scene,
+            camera,
+            initialCaptureOptions
+          )
+        };
+      });
+      try {
+        pausedRef.current = true;
+        stepsToRunRef.current = 0;
+        if (options.reset) reset();
+        for (let frameIndex = 0; frameIndex < frameCount; frameIndex += 1) {
+          throwIfCameraSequenceAborted(options.signal);
+          if (stepsPerFrame > 0 && (frameIndex > 0 || options.captureInitialFrame === false)) {
+            await stepCameraSequence(frameIndex, stepsPerFrame);
+          }
+          await waitForNextAnimationFrame2();
+          throwIfCameraSequenceAborted(options.signal);
+          const model = mjModelRef.current;
+          const data = mjDataRef.current;
+          if (!model || !data) {
+            throw new Error("MuJoCo scene is not ready for camera sequence sampling.");
+          }
+          await options.onSample?.({
+            frameIndex,
+            time: data.time,
+            model,
+            data
+          });
+          const cameraFrames = {};
+          for (const { key, captureOptions, mountedSource, session } of captureSessions) {
+            const resolvedCaptureOptions = resolveCameraCaptureOptions(captureOptions);
+            const cameraFrame = session.captureDataUrl({
+              ...resolvedCaptureOptions,
+              source: mountedSource ?? resolvedCaptureOptions.source
+            });
+            if (requireMountedSources) {
+              assertMatchingMountedCameraSource(
+                key,
+                captureOptions,
+                cameraFrame.source
+              );
+            }
+            cameraSummaries[key] = {
+              key,
+              width: cameraFrame.width,
+              height: cameraFrame.height,
+              source: cameraFrame.source,
+              frameCount: (cameraSummaries[key]?.frameCount ?? 0) + 1,
+              firstFrameIndex: cameraSummaries[key]?.firstFrameIndex ?? frameIndex,
+              lastFrameIndex: frameIndex,
+              firstTimestamp: cameraSummaries[key]?.firstTimestamp ?? data.time,
+              lastTimestamp: data.time
+            };
+            cameraFrames[key] = cameraFrame;
+          }
+          const frame = {
+            frameIndex,
+            time: getTime(),
+            cameras: cameraFrames
+          };
+          if (retainFrames) {
+            frames.push(frame);
+          }
+          recordedFrameCount += 1;
+          await options.onFrame?.(frame);
+        }
+      } finally {
+        for (const { session } of captureSessions) {
+          session.dispose();
+        }
+        pausedRef.current = wasPaused;
+      }
+      return {
+        frames,
+        cameraKeys: cameras.map((sequenceCamera) => sequenceCamera.key),
+        cameraSummaries,
+        frameCount: recordedFrameCount
+      };
+    },
+    [camera, getTime, gl, mujoco, reset, resolveCameraCaptureOptions, scene]
+  );
   const project2DTo3D = useCallback(
     (x, y, cameraPos, lookAt) => {
       const virtCam = camera.clone();
@@ -2278,9 +2982,9 @@ function MujocoSimProvider({
       _projNdc.set(x * 2 - 1, -(y * 2 - 1));
       _projRaycaster.setFromCamera(_projNdc, virtCam);
       const objects = [];
-      const scene = camera.parent;
-      if (scene) {
-        scene.traverse((c) => {
+      const scene2 = camera.parent;
+      if (scene2) {
+        scene2.traverse((c) => {
           if (c.isMesh) objects.push(c);
         });
       }
@@ -2363,6 +3067,7 @@ function MujocoSimProvider({
       getSites,
       getActuators: getActuatorsApi,
       getSensors,
+      getCameras,
       getModelOption,
       setGravity,
       setTimestep: setTimestepApi,
@@ -2378,6 +3083,9 @@ function MujocoSimProvider({
       getCanvasSnapshot,
       captureFrame: captureFrameApi,
       captureFrameBlob: captureFrameBlobApi,
+      captureCameraFrame: captureCameraFrameApi,
+      captureCameraFrameBlob: captureCameraFrameBlobApi,
+      recordCameraSequence: recordCameraSequenceApi,
       project2DTo3D,
       setBodyMass,
       setGeomFriction,
@@ -2418,6 +3126,7 @@ function MujocoSimProvider({
       getSites,
       getActuatorsApi,
       getSensors,
+      getCameras,
       getModelOption,
       setGravity,
       setTimestepApi,
@@ -2433,6 +3142,9 @@ function MujocoSimProvider({
       getCanvasSnapshot,
       captureFrameApi,
       captureFrameBlobApi,
+      captureCameraFrameApi,
+      captureCameraFrameBlobApi,
+      recordCameraSequenceApi,
       project2DTo3D,
       setBodyMass,
       setGeomFriction,
@@ -2899,7 +3611,7 @@ function solve6x6(A, b, x) {
 }
 
 // src/hooks/useIkController.ts
-var _syncMat4 = new THREE11.Matrix4();
+var _syncMat4 = new THREE12.Matrix4();
 function syncGizmoToSite(data, siteId, target) {
   if (siteId === -1) return;
   const sitePos = data.site_xpos.subarray(siteId * 3, siteId * 3 + 3);
@@ -2931,7 +3643,7 @@ var useIkController = createControllerHook(
     const { mjModelRef, mjDataRef, mujocoRef, resetCallbacks, status } = useMujocoContext();
     const ikEnabledRef = useRef(false);
     const ikCalculatingRef = useRef(false);
-    const ikTargetRef = useRef(new THREE11.Group());
+    const ikTargetRef = useRef(new THREE12.Group());
     const siteIdRef = useRef(-1);
     const controlGroupRef = useRef(null);
     const genericIkRef = useRef(new GenericIK(mujocoRef.current));
@@ -2939,10 +3651,10 @@ var useIkController = createControllerHook(
     const needsInitialSync = useRef(true);
     const gizmoAnimRef = useRef({
       active: false,
-      startPos: new THREE11.Vector3(),
-      endPos: new THREE11.Vector3(),
-      startRot: new THREE11.Quaternion(),
-      endRot: new THREE11.Quaternion(),
+      startPos: new THREE12.Vector3(),
+      endPos: new THREE12.Vector3(),
+      startRot: new THREE12.Quaternion(),
+      endRot: new THREE12.Quaternion(),
       startTime: 0,
       duration: 1e3
     });
@@ -3087,8 +3799,8 @@ var useIkController = createControllerHook(
         const target = ikTargetRef.current;
         if (!target) return;
         const targetPos = pos.clone();
-        const targetRot = new THREE11.Quaternion().setFromEuler(
-          new THREE11.Euler(Math.PI, 0, 0)
+        const targetRot = new THREE12.Quaternion().setFromEuler(
+          new THREE12.Euler(Math.PI, 0, 0)
         );
         if (duration > 0) {
           const ga = gizmoAnimRef.current;
@@ -3113,7 +3825,7 @@ var useIkController = createControllerHook(
         if (!ikCalculatingRef.current || !target) return null;
         return {
           pos: target.position.clone(),
-          rot: new THREE11.Euler().setFromQuaternion(target.quaternion)
+          rot: new THREE12.Euler().setFromQuaternion(target.quaternion)
         };
       },
       []
@@ -3209,10 +3921,10 @@ function Body({
   if (!hasChildren) return null;
   return /* @__PURE__ */ jsx("group", { ref: groupRef, children });
 }
-var _mat4 = new THREE11.Matrix4();
-var _pos = new THREE11.Vector3();
-var _quat = new THREE11.Quaternion();
-var _scale = new THREE11.Vector3(1, 1, 1);
+var _mat4 = new THREE12.Matrix4();
+var _pos = new THREE12.Vector3();
+var _quat = new THREE12.Quaternion();
+var _scale = new THREE12.Vector3(1, 1, 1);
 function IkGizmo({ controller, siteName, scale = 0.18, onDrag }) {
   const { mjModelRef, mjDataRef, status } = useMujocoContext();
   const { ikTargetRef, siteIdRef, ikEnabledRef, setIkEnabled } = controller;
@@ -3304,7 +4016,7 @@ function IkGizmo({ controller, siteName, scale = 0.18, onDrag }) {
     }
   ) });
 }
-var _dummy = new THREE11.Object3D();
+var _dummy = new THREE12.Object3D();
 function ContactMarkers({
   maxContacts = 100,
   radius = 8e-3,
@@ -3348,11 +4060,11 @@ function ContactMarkers({
 var _force = new Float64Array(3);
 var _torque = new Float64Array(3);
 var _point = new Float64Array(3);
-var _bodyPos = new THREE11.Vector3();
-var _bodyQuat = new THREE11.Quaternion();
-var _worldHit = new THREE11.Vector3();
-var _raycaster = new THREE11.Raycaster();
-var _mouse = new THREE11.Vector2();
+var _bodyPos = new THREE12.Vector3();
+var _bodyQuat = new THREE12.Quaternion();
+var _worldHit = new THREE12.Vector3();
+var _raycaster = new THREE12.Raycaster();
+var _mouse = new THREE12.Vector2();
 function DragInteraction({
   stiffness = 250,
   showArrow = true,
@@ -3363,16 +4075,16 @@ function DragInteraction({
   const draggingRef = useRef(false);
   const bodyIdRef = useRef(-1);
   const grabDistanceRef = useRef(0);
-  const localHitRef = useRef(new THREE11.Vector3());
-  const grabWorldRef = useRef(new THREE11.Vector3());
-  const mouseWorldRef = useRef(new THREE11.Vector3());
+  const localHitRef = useRef(new THREE12.Vector3());
+  const grabWorldRef = useRef(new THREE12.Vector3());
+  const mouseWorldRef = useRef(new THREE12.Vector3());
   const arrowRef = useRef(null);
   const groupRef = useRef(null);
   useEffect(() => {
     if (!showArrow || !groupRef.current) return;
-    const arrow = new THREE11.ArrowHelper(
-      new THREE11.Vector3(0, 1, 0),
-      new THREE11.Vector3(),
+    const arrow = new THREE12.ArrowHelper(
+      new THREE12.Vector3(0, 1, 0),
+      new THREE12.Vector3(),
       0.1,
       16729156
     );
@@ -3554,7 +4266,7 @@ function useSceneLights(intensity = 1) {
       const dr = lightDiffuse ? lightDiffuse[3 * i] : 1;
       const dg = lightDiffuse ? lightDiffuse[3 * i + 1] : 1;
       const db = lightDiffuse ? lightDiffuse[3 * i + 2] : 1;
-      const color = new THREE11.Color(dr, dg, db);
+      const color = new THREE12.Color(dr, dg, db);
       const px = lightPos[3 * i];
       const py = lightPos[3 * i + 1];
       const pz = lightPos[3 * i + 2];
@@ -3562,7 +4274,7 @@ function useSceneLights(intensity = 1) {
       const dy = lightDir[3 * i + 1];
       const dz = lightDir[3 * i + 2];
       if (isDirectional) {
-        const light = new THREE11.DirectionalLight(color, finalIntensity);
+        const light = new THREE12.DirectionalLight(color, finalIntensity);
         light.position.set(px, py, pz);
         light.target.position.set(px + dx, py + dy, pz + dz);
         light.castShadow = castShadow;
@@ -3585,7 +4297,7 @@ function useSceneLights(intensity = 1) {
         const cutoff = lightCutoff ? lightCutoff[i] : 45;
         const exponent = lightExponent ? lightExponent[i] : 10;
         const angle = cutoff * Math.PI / 180;
-        const light = new THREE11.SpotLight(color, finalIntensity, 0, angle, exponent / 128);
+        const light = new THREE12.SpotLight(color, finalIntensity, 0, angle, exponent / 128);
         light.position.set(px, py, pz);
         light.target.position.set(px + dx, py + dy, pz + dz);
         light.castShadow = castShadow;
@@ -3643,11 +4355,11 @@ var JOINT_COLORS = {
   3: 16776960
   // hinge - yellow
 };
-var _v3a = new THREE11.Vector3();
-new THREE11.Vector3();
-var _quat2 = new THREE11.Quaternion();
-var _contactPos = new THREE11.Vector3();
-var _contactNormal = new THREE11.Vector3();
+var _v3a = new THREE12.Vector3();
+new THREE12.Vector3();
+var _quat2 = new THREE12.Quaternion();
+var _contactPos = new THREE12.Vector3();
+var _contactNormal = new THREE12.Vector3();
 var MAX_CONTACT_ARROWS = 50;
 function Debug({
   showGeoms = false,
@@ -3676,21 +4388,21 @@ function Debug({
         let geometry = null;
         switch (type) {
           case 2:
-            geometry = new THREE11.SphereGeometry(s[3 * i], 12, 8);
+            geometry = new THREE12.SphereGeometry(s[3 * i], 12, 8);
             break;
           case 3:
-            geometry = new THREE11.CapsuleGeometry(s[3 * i], s[3 * i + 1] * 2, 6, 8);
+            geometry = new THREE12.CapsuleGeometry(s[3 * i], s[3 * i + 1] * 2, 6, 8);
             break;
           case 5:
-            geometry = new THREE11.CylinderGeometry(s[3 * i], s[3 * i], s[3 * i + 1] * 2, 12);
+            geometry = new THREE12.CylinderGeometry(s[3 * i], s[3 * i], s[3 * i + 1] * 2, 12);
             break;
           case 6:
-            geometry = new THREE11.BoxGeometry(s[3 * i] * 2, s[3 * i + 1] * 2, s[3 * i + 2] * 2);
+            geometry = new THREE12.BoxGeometry(s[3 * i] * 2, s[3 * i + 1] * 2, s[3 * i + 2] * 2);
             break;
         }
         if (geometry) {
-          const mat = new THREE11.MeshBasicMaterial({ color: 65280, wireframe: true, transparent: true, opacity: 0.3 });
-          const mesh = new THREE11.Mesh(geometry, mat);
+          const mat = new THREE12.MeshBasicMaterial({ color: 65280, wireframe: true, transparent: true, opacity: 0.3 });
+          const mesh = new THREE12.Mesh(geometry, mat);
           mesh.userData.geomId = i;
           mesh.userData.bodyId = model.geom_bodyid[i];
           geoms.push(mesh);
@@ -3713,9 +4425,9 @@ function Debug({
           }
           if (maxGeomSize > 0) radius = maxGeomSize * 0.15;
         }
-        const geometry = new THREE11.OctahedronGeometry(radius);
-        const mat = new THREE11.MeshBasicMaterial({ color: 16711935, depthTest: false });
-        const mesh = new THREE11.Mesh(geometry, mat);
+        const geometry = new THREE12.OctahedronGeometry(radius);
+        const mat = new THREE12.MeshBasicMaterial({ color: 16711935, depthTest: false });
+        const mesh = new THREE12.Mesh(geometry, mat);
         mesh.renderOrder = 999;
         mesh.frustumCulled = false;
         mesh.userData.siteId = i;
@@ -3727,9 +4439,9 @@ function Debug({
         ctx.font = "bold 36px monospace";
         ctx.textAlign = "center";
         ctx.fillText(getName(model, model.name_siteadr[i]), 128, 42);
-        const tex = new THREE11.CanvasTexture(canvas);
-        const spriteMat = new THREE11.SpriteMaterial({ map: tex, depthTest: false, transparent: true });
-        const sprite = new THREE11.Sprite(spriteMat);
+        const tex = new THREE12.CanvasTexture(canvas);
+        const spriteMat = new THREE12.SpriteMaterial({ map: tex, depthTest: false, transparent: true });
+        const sprite = new THREE12.Sprite(spriteMat);
         const labelScale = radius * 15;
         sprite.scale.set(labelScale, labelScale * 0.25, 1);
         sprite.position.y = radius * 2;
@@ -3752,9 +4464,9 @@ function Debug({
           }
         }
         const arrowLen = Math.max(maxGeomSize * 0.8, 0.05);
-        const arrow = new THREE11.ArrowHelper(
-          new THREE11.Vector3(0, 0, 1),
-          new THREE11.Vector3(),
+        const arrow = new THREE12.ArrowHelper(
+          new THREE12.Vector3(0, 0, 1),
+          new THREE12.Vector3(),
           arrowLen,
           color,
           arrowLen * 0.25,
@@ -3762,7 +4474,7 @@ function Debug({
         );
         arrow.renderOrder = 999;
         arrow.frustumCulled = false;
-        arrow.line.material = new THREE11.LineBasicMaterial({ color, depthTest: false });
+        arrow.line.material = new THREE12.LineBasicMaterial({ color, depthTest: false });
         arrow.cone.material.depthTest = false;
         arrow.line.renderOrder = 999;
         arrow.line.frustumCulled = false;
@@ -3777,9 +4489,9 @@ function Debug({
     }
     if (showCOM) {
       for (let i = 1; i < model.nbody; i++) {
-        const geometry = new THREE11.SphereGeometry(5e-3, 6, 6);
-        const mat = new THREE11.MeshBasicMaterial({ color: 16711680 });
-        const mesh = new THREE11.Mesh(geometry, mat);
+        const geometry = new THREE12.SphereGeometry(5e-3, 6, 6);
+        const mat = new THREE12.MeshBasicMaterial({ color: 16711680 });
+        const mesh = new THREE12.Mesh(geometry, mat);
         mesh.userData.bodyId = i;
         comMarkers.push(mesh);
       }
@@ -3870,9 +4582,9 @@ function Debug({
     contactPoolInitRef.current = true;
     const pool = [];
     for (let i = 0; i < MAX_CONTACT_ARROWS; i++) {
-      const arrow = new THREE11.ArrowHelper(
-        new THREE11.Vector3(0, 1, 0),
-        new THREE11.Vector3(),
+      const arrow = new THREE12.ArrowHelper(
+        new THREE12.Vector3(0, 1, 0),
+        new THREE12.Vector3(),
         0.1,
         16729156,
         0.03,
@@ -3927,9 +4639,9 @@ function Debug({
     showContacts && /* @__PURE__ */ jsx("group", { ref: contactGroupRef })
   ] });
 }
-var DEFAULT_TENDON_COLOR = new THREE11.Color(0.3, 0.3, 0.8);
+var DEFAULT_TENDON_COLOR = new THREE12.Color(0.3, 0.3, 0.8);
 var DEFAULT_TENDON_WIDTH = 2e-3;
-new THREE11.Vector3();
+new THREE12.Vector3();
 function TendonRenderer(props) {
   const { mjModelRef, mjDataRef, status } = useMujocoContext();
   const groupRef = useRef(null);
@@ -3943,7 +4655,7 @@ function TendonRenderer(props) {
     if (!model || !data || !group) return;
     const ntendon = model.ntendon ?? 0;
     if (ntendon === 0) return;
-    const material = new THREE11.MeshStandardMaterial({
+    const material = new THREE12.MeshStandardMaterial({
       color: DEFAULT_TENDON_COLOR,
       roughness: 0.6,
       metalness: 0.1
@@ -3958,11 +4670,11 @@ function TendonRenderer(props) {
         curves.push(null);
         continue;
       }
-      const points = Array.from({ length: wrapNum }, () => new THREE11.Vector3());
-      const curve = new THREE11.CatmullRomCurve3(points, false);
+      const points = Array.from({ length: wrapNum }, () => new THREE12.Vector3());
+      const curve = new THREE12.CatmullRomCurve3(points, false);
       const segments = Math.max(wrapNum * 2, 4);
-      const geometry = new THREE11.TubeGeometry(curve, segments, DEFAULT_TENDON_WIDTH, 6, false);
-      const mesh = new THREE11.Mesh(geometry, material);
+      const geometry = new THREE12.TubeGeometry(curve, segments, DEFAULT_TENDON_WIDTH, 6, false);
+      const mesh = new THREE12.Mesh(geometry, material);
       mesh.frustumCulled = false;
       group.add(mesh);
       meshes.push(mesh);
@@ -4017,11 +4729,11 @@ function TendonRenderer(props) {
       if (curve.points.length !== validCount) {
         curve.points.length = validCount;
         while (curve.points.length < validCount) {
-          curve.points.push(new THREE11.Vector3());
+          curve.points.push(new THREE12.Vector3());
         }
       }
       mesh.geometry.dispose();
-      mesh.geometry = new THREE11.TubeGeometry(
+      mesh.geometry = new THREE12.TubeGeometry(
         curve,
         Math.max(validCount * 2, 4),
         DEFAULT_TENDON_WIDTH,
@@ -4048,24 +4760,24 @@ function FlexRenderer(props) {
       const vertAdr = model.flex_vertadr[f];
       const vertNum = model.flex_vertnum[f];
       if (vertNum === 0) continue;
-      const geometry = new THREE11.BufferGeometry();
+      const geometry = new THREE12.BufferGeometry();
       const positions = new Float32Array(vertNum * 3);
-      geometry.setAttribute("position", new THREE11.BufferAttribute(positions, 3));
+      geometry.setAttribute("position", new THREE12.BufferAttribute(positions, 3));
       geometry.computeVertexNormals();
-      let color = new THREE11.Color(0.5, 0.5, 0.5);
+      let color = new THREE12.Color(0.5, 0.5, 0.5);
       if (model.flex_rgba) {
-        color = new THREE11.Color(
+        color = new THREE12.Color(
           model.flex_rgba[4 * f],
           model.flex_rgba[4 * f + 1],
           model.flex_rgba[4 * f + 2]
         );
       }
-      const material = new THREE11.MeshStandardMaterial({
+      const material = new THREE12.MeshStandardMaterial({
         color,
         roughness: 0.7,
-        side: THREE11.DoubleSide
+        side: THREE12.DoubleSide
       });
-      const mesh = new THREE11.Mesh(geometry, material);
+      const mesh = new THREE12.Mesh(geometry, material);
       mesh.userData.flexId = f;
       mesh.userData.vertAdr = vertAdr;
       mesh.userData.vertNum = vertNum;
@@ -4101,7 +4813,7 @@ function FlexRenderer(props) {
   return /* @__PURE__ */ jsx("group", { ...props, ref: groupRef });
 }
 var GEOM_TYPE_NAMES2 = ["plane", "hfield", "sphere", "capsule", "ellipsoid", "cylinder", "box", "mesh"];
-var _matrix = new THREE11.Matrix4();
+var _matrix = new THREE12.Matrix4();
 function getGeomInfo(model, geomId) {
   const size = model.geom_size.subarray(geomId * 3, geomId * 3 + 3);
   const type = model.geom_type[geomId];
@@ -4123,10 +4835,10 @@ function geomSignature(model, geomId) {
   return [type, size, mat, data, rgba].join("|");
 }
 function firstMesh(object) {
-  if (object instanceof THREE11.Mesh) return object;
+  if (object instanceof THREE12.Mesh) return object;
   let mesh = null;
   object.traverse((child) => {
-    if (!mesh && child instanceof THREE11.Mesh) mesh = child;
+    if (!mesh && child instanceof THREE12.Mesh) mesh = child;
   });
   return mesh;
 }
@@ -4555,12 +5267,12 @@ function useActuators() {
     return actuators;
   }, [status, mjModelRef]);
 }
-var _mat42 = new THREE11.Matrix4();
+var _mat42 = new THREE12.Matrix4();
 function useSitePosition(siteName) {
   const { mjModelRef, mjDataRef, status } = useMujocoContext();
   const siteIdRef = useRef(-1);
-  const positionRef = useRef(new THREE11.Vector3());
-  const quaternionRef = useRef(new THREE11.Quaternion());
+  const positionRef = useRef(new THREE12.Vector3());
+  const quaternionRef = useRef(new THREE12.Quaternion());
   useEffect(() => {
     const model = mjModelRef.current;
     if (!model || status !== "ready") {
@@ -4751,10 +5463,10 @@ function useJointState(name) {
 function useBodyState(name) {
   const { mjModelRef, status } = useMujocoContext();
   const bodyIdRef = useRef(-1);
-  const position = useRef(new THREE11.Vector3());
-  const quaternion = useRef(new THREE11.Quaternion());
-  const linearVelocity = useRef(new THREE11.Vector3());
-  const angularVelocity = useRef(new THREE11.Vector3());
+  const position = useRef(new THREE12.Vector3());
+  const quaternion = useRef(new THREE12.Quaternion());
+  const linearVelocity = useRef(new THREE12.Vector3());
+  const angularVelocity = useRef(new THREE12.Vector3());
   useEffect(() => {
     const model = mjModelRef.current;
     if (!model || status !== "ready") return;
@@ -5108,6 +5820,157 @@ function useVideoRecorder(options = {}) {
     }
   };
 }
+function useCameraFrameCapture(defaultOptions = {}) {
+  const mujoco = useMujoco();
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+  }, []);
+  const capture = useCallback(
+    async (options = {}) => {
+      if (!mujoco.api) {
+        throw new Error("MuJoCo scene is not ready for camera frame capture.");
+      }
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await mujoco.api.captureCameraFrame({
+          ...defaultOptions,
+          ...options
+        });
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to capture the requested camera frame.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [defaultOptions, mujoco.api]
+  );
+  const captureBlob = useCallback(
+    async (options = {}) => {
+      if (!mujoco.api) {
+        throw new Error("MuJoCo scene is not ready for camera frame capture.");
+      }
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await mujoco.api.captureCameraFrameBlob({
+          ...defaultOptions,
+          ...options
+        });
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to capture the requested camera frame.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [defaultOptions, mujoco.api]
+  );
+  return {
+    status,
+    error,
+    isCapturing: status === "capturing",
+    capture,
+    captureBlob,
+    reset
+  };
+}
+function useCameraSequenceRecorder() {
+  const mujoco = useMujoco();
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+  }, []);
+  const record = useCallback(
+    async (options) => {
+      if (!mujoco.api) {
+        throw new Error("MuJoCo scene is not ready for camera sequence recording.");
+      }
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await mujoco.api.recordCameraSequence(options);
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to record the requested camera sequence.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [mujoco.api]
+  );
+  return {
+    status,
+    error,
+    isRecording: status === "capturing",
+    record,
+    reset
+  };
+}
+function useMountedCameraSequenceRecorder(defaultOptions = {}) {
+  const mujoco = useMujoco();
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+  }, []);
+  const createPlan = useCallback(
+    (cameraKeys, options = {}) => {
+      if (!mujoco.api) {
+        throw new Error("MuJoCo scene is not ready for mounted camera sequence planning.");
+      }
+      return createMountedCameraFrameSequencePlanFromApi(mujoco.api, cameraKeys, {
+        ...defaultOptions,
+        ...options
+      });
+    },
+    [defaultOptions, mujoco.api]
+  );
+  const record = useCallback(
+    async (options) => {
+      if (!mujoco.api) {
+        throw new Error("MuJoCo scene is not ready for mounted camera sequence recording.");
+      }
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await recordMountedCameraFrameSequence(mujoco.api, {
+          ...defaultOptions,
+          ...options
+        });
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to record the requested mounted camera sequence.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [defaultOptions, mujoco.api]
+  );
+  return {
+    status,
+    error,
+    isRecording: status === "capturing",
+    createPlan,
+    record,
+    reset
+  };
+}
 function useCtrlNoise(config = {}) {
   const { mjModelRef } = useMujocoContext();
   const configRef = useRef(config);
@@ -5159,7 +6022,7 @@ function useSelectionHighlight(bodyId, options = {}) {
       }
     }
     prevRef.current = [];
-    const highlightColor = new THREE11.Color(color);
+    const highlightColor = new THREE12.Color(color);
     for (const mesh of meshes) {
       const mat = mesh.material;
       if (mat.emissive) {
@@ -5186,15 +6049,15 @@ function useSelectionHighlight(bodyId, options = {}) {
 }
 function useCameraAnimation() {
   const { camera } = useThree();
-  const orbitTargetRef = useRef(new THREE11.Vector3(0, 0, 0));
+  const orbitTargetRef = useRef(new THREE12.Vector3(0, 0, 0));
   const cameraAnimRef = useRef({
     active: false,
-    startPos: new THREE11.Vector3(),
-    endPos: new THREE11.Vector3(),
-    startRot: new THREE11.Quaternion(),
-    endRot: new THREE11.Quaternion(),
-    startTarget: new THREE11.Vector3(),
-    endTarget: new THREE11.Vector3(),
+    startPos: new THREE12.Vector3(),
+    endPos: new THREE12.Vector3(),
+    startRot: new THREE12.Quaternion(),
+    endRot: new THREE12.Quaternion(),
+    startTarget: new THREE12.Vector3(),
+    endTarget: new THREE12.Vector3(),
     startTime: 0,
     duration: 0,
     resolve: null
@@ -5266,6 +6129,18 @@ function useCameraAnimation() {
  *
  * useFrameCapture — still-frame capture for canvas-backed MuJoCo/R3F scenes.
  */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Offscreen camera-frame capture for R3F/MuJoCo scenes.
+ */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Helpers for resolving dataset camera streams to mounted MuJoCo resources.
+ */
 /**
  * @license
  * SPDX-License-Identifier: Apache-2.0
@@ -5399,6 +6274,24 @@ function useCameraAnimation() {
  *
  * useVideoRecorder — canvas video recording hook (spec 13.3)
  */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * React state wrapper around MuJoCo/R3F offscreen camera-frame capture.
+ */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * React state wrapper around fixed-camera simulation sequence recording.
+ */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * React state wrapper for named MuJoCo camera/site/body sequence recording.
+ */
 /**
  * @license
  * SPDX-License-Identifier: Apache-2.0
@@ -5429,6 +6322,6 @@ function useCameraAnimation() {
  * useCameraAnimation — composable camera animation hook.
  */
 
-export { Body, ContactListener, ContactMarkers, Debug, DragInteraction, FlexRenderer, IkGizmo, InstancedGeomRenderer, MujocoCanvas, MujocoPhysics, MujocoProvider, MujocoSimProvider, RobotActuators, RobotBodies, RobotGeoms, RobotJoints, RobotKeyframes, RobotResources, RobotSensors, RobotSites, SceneLights, TendonRenderer, TrajectoryPlayer, buildObservation, captureFrame, captureFrameBlob, createContiguousControlGroup, createController, createControllerHook, findActuatorByName, findBodyByName, findGeomByName, findJointByName, findKeyframeByName, findSensorByName, findSiteByName, findTendonByName, getActuatedJoints, getContact, getControlMap, getName, loadScene, registerRobotResources, resolveControlGroup, useActuators, useAfterPhysicsStep, useBeforePhysicsStep, useBodyMeshes, useBodyState, useCameraAnimation, useContactEvents, useContacts, useCtrl, useCtrlNoise, useFrameCapture, useGamepad, useGravityCompensation, useIkController, useJointState, useKeyboardTeleop, useMujoco, useMujocoWasm, useObservation, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };
+export { Body, ContactListener, ContactMarkers, Debug, DragInteraction, FlexRenderer, IkGizmo, InstancedGeomRenderer, MountedCameraFrameSequenceReadinessStatus, MujocoCanvas, MujocoPhysics, MujocoProvider, MujocoSimProvider, SceneLights, TendonRenderer, TrajectoryPlayer, buildObservation, captureCameraFrame, captureCameraFrameBlob, captureFrame, captureFrameBlob, createCameraFrameCaptureSession, createContiguousControlGroup, createController, createControllerHook, createMountedCameraFrameSequencePlan, createMountedCameraFrameSequencePlanFromApi, createMountedCameraFrameSequenceReadiness, findActuatorByName, findBodyByName, findGeomByName, findJointByName, findKeyframeByName, findSensorByName, findSiteByName, findTendonByName, getActuatedJoints, getCameraFrameCaptureSourceTarget, getControlMap, getMountedCameraFrameCaptureSource, getName, isMountedCameraFrameCaptureSource, loadScene, recordMountedCameraFrameSequence, renderCameraFrameToCanvas, resolveControlGroup, resolveMountedCameraFrameSource, useActuators, useAfterPhysicsStep, useBeforePhysicsStep, useBodyMeshes, useBodyState, useCameraAnimation, useCameraFrameCapture, useCameraSequenceRecorder, useContactEvents, useContacts, useCtrl, useCtrlNoise, useFrameCapture, useGamepad, useGravityCompensation, useIkController, useJointState, useKeyboardTeleop, useMountedCameraSequenceRecorder, useMujoco, useMujocoWasm, useObservation, usePolicy, useSceneLights, useSelectionHighlight, useSensor, useSensors, useSitePosition, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map