npm - mujoco-react - Versions diffs - 8.9.2 → 8.11.0 - Mend

mujoco-react 8.9.2 → 8.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/README.md +82 -1
package/dist/chunk-SEWQULWO.js +400 -0
package/dist/chunk-SEWQULWO.js.map +1 -0
package/dist/index.d.ts +114 -744
package/dist/index.js +329 -35
package/dist/index.js.map +1 -1
package/dist/spark.d.ts +53 -0
package/dist/spark.js +235 -0
package/dist/spark.js.map +1 -0
package/dist/types-BmneHLBM.d.ts +871 -0
package/dist/vite.d.ts +9 -0
package/dist/vite.js +4 -0
package/dist/vite.js.map +1 -1
package/package.json +15 -2
package/src/components/Body.tsx +3 -1
package/src/components/VisualScenario.tsx +566 -0
package/src/core/MujocoCanvas.tsx +8 -1
package/src/core/SceneLoader.ts +182 -3
package/src/hooks/useFrameCapture.ts +206 -0
package/src/hooks/usePolicy.ts +12 -8
package/src/hooks/useSceneLights.ts +49 -18
package/src/index.ts +48 -0
package/src/spark.tsx +336 -0
package/src/types.ts +159 -3
package/src/vite.ts +8 -0

package/dist/index.js CHANGED Viewed

@@ -1,3 +1,4 @@
+export { ScenarioLighting, SplatEnvironment, VisualScenarioEffects, createPairedSplatEnvironment, createSparkSplatViewerUrl, createSplatEnvironmentUserData, getScenarioBackground, getScenarioCameraPosition, useSplatEnvironment, useVisualScenarioEffects, withSplatEnvironment } from './chunk-SEWQULWO.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';
@@ -6,7 +7,6 @@ import { Canvas, useThree, useFrame } from '@react-three/fiber';
 import * as THREE11 from 'three';
 import { PivotControls } from '@react-three/drei';
-// src/core/MujocoProvider.tsx
 var MujocoContext = createContext({
   mujoco: null,
   status: "loading",
@@ -776,7 +776,8 @@ function sceneObjectToXml(obj) {
   const solref = obj.solref ? ` solref="${obj.solref}"` : "";
   const solimp = obj.solimp ? ` solimp="${obj.solimp}"` : "";
   const condim = obj.condim ? ` condim="${obj.condim}"` : "";
-  return `<body name="${obj.name}" pos="${pos}">${joint}<geom type="${obj.type}" size="${size}" rgba="${rgba}" contype="1" conaffinity="1"${mass}${friction}${solref}${solimp}${condim}/></body>`;
+  const group = obj.group !== void 0 ? ` group="${obj.group}"` : "";
+  return `<body name="${obj.name}" pos="${pos}">${joint}<geom type="${obj.type}" size="${size}" rgba="${rgba}" contype="1" conaffinity="1"${mass}${friction}${solref}${solimp}${condim}${group}/></body>`;
 }
 function ensureDir(mujoco, fname) {
   const dirParts = fname.split("/");
@@ -816,6 +817,20 @@ function normalizeVfsPath(path) {
 function localFilePath(file) {
   return normalizeVfsPath(file.webkitRelativePath || file.name);
 }
+function dirname(path) {
+  const normalized = normalizeVfsPath(path);
+  const idx = normalized.lastIndexOf("/");
+  return idx === -1 ? "" : normalized.slice(0, idx + 1);
+}
+function relativeVfsPath(fromDir, targetPath) {
+  const from = normalizeVfsPath(fromDir).split("/").filter(Boolean);
+  const target = normalizeVfsPath(targetPath).split("/").filter(Boolean);
+  while (from.length && target.length && from[0] === target[0]) {
+    from.shift();
+    target.shift();
+  }
+  return [...from.map(() => ".."), ...target].join("/") || ".";
+}
 function inferSceneFile(files, options) {
   if (options?.sceneFile) return normalizeVfsPath(options.sceneFile);
   const paths = files.map(localFilePath);
@@ -834,12 +849,120 @@ function createSceneConfigFromFiles(files, options = {}) {
     src: "",
     sceneFile: inferSceneFile(fileArray, options),
     files: fileArray,
+    environmentFiles: options.environmentFiles?.map(normalizeVfsPath),
     homeJoints: options.homeJoints,
     xmlPatches: options.xmlPatches,
     sceneObjects: options.sceneObjects,
     onReset: options.onReset
   };
 }
+var ENVIRONMENT_MERGE_SECTIONS = [
+  "asset",
+  "worldbody",
+  "contact",
+  "equality",
+  "tendon",
+  "sensor",
+  "keyframe",
+  "custom",
+  "extension"
+];
+function directChild(parent, tagName) {
+  const lower = tagName.toLowerCase();
+  for (const child of Array.from(parent.children)) {
+    if (child.tagName.toLowerCase() === lower) return child;
+  }
+  return null;
+}
+function ensureTopLevelSection(doc, tagName) {
+  const root = doc.documentElement;
+  const existing = directChild(root, tagName);
+  if (existing) return existing;
+  const section = doc.createElement(tagName);
+  if (tagName === "asset") {
+    const worldbody = directChild(root, "worldbody");
+    if (worldbody) root.insertBefore(section, worldbody);
+    else root.appendChild(section);
+  } else {
+    root.appendChild(section);
+  }
+  return section;
+}
+function readCompilerDirs(doc) {
+  const compiler = directChild(doc.documentElement, "compiler");
+  const assetDir = compiler?.getAttribute("assetdir") || "";
+  return {
+    meshDir: compiler?.getAttribute("meshdir") || assetDir,
+    textureDir: compiler?.getAttribute("texturedir") || assetDir
+  };
+}
+function isExternalPath(path) {
+  return /^[a-z]+:\/\//i.test(path) || path.startsWith("package://") || path.startsWith("/");
+}
+function fileReferencePrefix(el, compilerDirs) {
+  const tag = el.tagName.toLowerCase();
+  if (tag === "mesh") return compilerDirs.meshDir ? compilerDirs.meshDir + "/" : "";
+  if (tag === "texture" || tag === "hfield") return compilerDirs.textureDir ? compilerDirs.textureDir + "/" : "";
+  return "";
+}
+function rewriteFileReferencesForMerge(node, sourceFile, targetFile, sourceDoc) {
+  const sourceDir = dirname(sourceFile);
+  const targetDir = dirname(targetFile);
+  const compilerDirs = readCompilerDirs(sourceDoc);
+  node.querySelectorAll("[file], [filename]").forEach((el) => {
+    const attr = el.hasAttribute("file") ? "file" : "filename";
+    const value = el.getAttribute(attr);
+    if (!value || isExternalPath(value)) return;
+    const sourceRelativePath = normalizeVfsPath(fileReferencePrefix(el, compilerDirs) + value);
+    const resolvedPath = normalizeVfsPath(sourceDir + sourceRelativePath);
+    el.setAttribute(attr, relativeVfsPath(targetDir, resolvedPath));
+  });
+}
+function hasParseError(doc) {
+  return doc.getElementsByTagName("parsererror").length > 0;
+}
+function composeEnvironmentXml(sceneXml, config, parser, environmentXmlByPath) {
+  const environmentFiles = config.environmentFiles?.map(normalizeVfsPath) ?? [];
+  if (!environmentFiles.length) return sceneXml;
+  const sceneDoc = parser.parseFromString(sceneXml, "text/xml");
+  if (hasParseError(sceneDoc)) {
+    console.warn(`Could not compose environments: failed to parse ${config.sceneFile}`);
+    return sceneXml;
+  }
+  for (const environmentFile of environmentFiles) {
+    const environmentXml = environmentXmlByPath.get(environmentFile);
+    if (!environmentXml) {
+      console.warn(`Environment XML not found: ${environmentFile}`);
+      continue;
+    }
+    const environmentDoc = parser.parseFromString(environmentXml, "text/xml");
+    if (hasParseError(environmentDoc)) {
+      console.warn(`Skipping environment XML with parse errors: ${environmentFile}`);
+      continue;
+    }
+    for (const sectionName of ENVIRONMENT_MERGE_SECTIONS) {
+      const environmentSection = directChild(environmentDoc.documentElement, sectionName);
+      if (!environmentSection?.children.length) continue;
+      const targetSection = ensureTopLevelSection(sceneDoc, sectionName);
+      for (const child of Array.from(environmentSection.children)) {
+        const imported = sceneDoc.importNode(child, true);
+        rewriteFileReferencesForMerge(imported, environmentFile, config.sceneFile, environmentDoc);
+        targetSection.appendChild(imported);
+      }
+    }
+  }
+  return new XMLSerializer().serializeToString(sceneDoc);
+}
+function findTextByConfiguredPath(textByPath, configuredPath) {
+  const normalized = normalizeVfsPath(configuredPath);
+  const direct = textByPath.get(normalized);
+  if (direct) return direct;
+  const suffix = "/" + normalized;
+  for (const [path, text] of textByPath) {
+    if (path.endsWith(suffix) || path === normalized.split("/").pop()) return text;
+  }
+  return void 0;
+}
 function applyXmlPatches(text, fname, config) {
   let result = text;
   for (const patch of config.xmlPatches ?? []) {
@@ -902,10 +1025,21 @@ async function loadSceneFromFiles(mujoco, config, onProgress) {
     if (isModelTextFile(path)) {
       const text = applyXmlPatches(await file.text(), path, config);
       textByPath.set(path, text);
-      mujoco.FS.writeFile(`/working/${path}`, text);
     } else {
       mujoco.FS.writeFile(`/working/${path}`, new Uint8Array(await file.arrayBuffer()));
+      written.add(path);
     }
+  }
+  const environmentXmlByPath = /* @__PURE__ */ new Map();
+  for (const environmentFile of config.environmentFiles?.map(normalizeVfsPath) ?? []) {
+    const environmentXml = findTextByConfiguredPath(textByPath, environmentFile);
+    if (environmentXml) environmentXmlByPath.set(environmentFile, environmentXml);
+  }
+  for (const [path, text] of textByPath) {
+    const composedText = path === config.sceneFile ? composeEnvironmentXml(text, config, parser, environmentXmlByPath) : text;
+    textByPath.set(path, composedText);
+    ensureDir(mujoco, path);
+    mujoco.FS.writeFile(`/working/${path}`, composedText);
     written.add(path);
   }
   for (const [path, text] of textByPath) {
@@ -954,6 +1088,17 @@ async function loadScene(mujoco, config, onProgress) {
   } catch {
   }
   const baseUrl = config.src.endsWith("/") ? config.src : config.src + "/";
+  const environmentXmlByPath = /* @__PURE__ */ new Map();
+  const environmentFiles = config.environmentFiles?.map(normalizeVfsPath) ?? [];
+  for (const environmentFile of environmentFiles) {
+    onProgress?.(`Downloading ${environmentFile}...`);
+    const res = await fetch(baseUrl + environmentFile);
+    if (!res.ok) {
+      console.warn(`Failed to fetch environment XML ${environmentFile}: ${res.status} ${res.statusText}`);
+      continue;
+    }
+    environmentXmlByPath.set(environmentFile, applyXmlPatches(await res.text(), environmentFile, config));
+  }
   const downloaded = /* @__PURE__ */ new Set();
   const xmlQueue = [config.sceneFile];
   const assetFiles = [];
@@ -972,7 +1117,8 @@ async function loadScene(mujoco, config, onProgress) {
       console.warn(`Failed to fetch ${fname}: ${res.status} ${res.statusText}`);
       continue;
     }
-    const text = applyXmlPatches(await res.text(), fname, config);
+    const patchedText = applyXmlPatches(await res.text(), fname, config);
+    const text = fname === config.sceneFile ? composeEnvironmentXml(patchedText, config, parser, environmentXmlByPath) : patchedText;
     ensureDir(mujoco, fname);
     mujoco.FS.writeFile(`/working/${fname}`, text);
     scanDependencies(text, fname, parser, downloaded, xmlQueue);
@@ -2209,6 +2355,7 @@ var MujocoCanvas = forwardRef(
     paused,
     speed,
     interpolate,
+    loadingFallback,
     children,
     ...canvasProps
   }, ref) {
@@ -2218,7 +2365,10 @@ var MujocoCanvas = forwardRef(
         onError(new Error(wasmError ?? "WASM load failed"));
       }
     }, [wasmStatus, wasmError, onError]);
-    if (wasmStatus === "error" || wasmStatus === "loading" || !mujoco) {
+    if (wasmStatus === "loading" || !mujoco) {
+      return loadingFallback ? /* @__PURE__ */ jsx(Canvas, { ...canvasProps, children: loadingFallback }) : null;
+    }
+    if (wasmStatus === "error") {
       return null;
     }
     return /* @__PURE__ */ jsx(Canvas, { ...canvasProps, children: /* @__PURE__ */ jsx(
@@ -2860,6 +3010,7 @@ function Body({
   solref,
   solimp,
   condim,
+  group,
   children
 }) {
   const { bodyRegistryRef, hiddenBodiesRef, requestBodyReload, mjDataRef, mjModelRef, status } = useMujocoContext();
@@ -2879,7 +3030,8 @@ function Body({
       friction,
       solref,
       solimp,
-      condim
+      condim,
+      group
     };
     bodyRegistryRef.current.set(name, { definition, hasCustomChildren: hasChildren });
     if (hasChildren) {
@@ -2892,7 +3044,7 @@ function Body({
         requestBodyReload();
       }
     };
-  }, [name, type, size, position, rgba, mass, freejoint, friction, solref, solimp, condim, hasChildren, bodyRegistryRef, hiddenBodiesRef, requestBodyReload]);
+  }, [name, type, size, position, rgba, mass, freejoint, friction, solref, solimp, condim, group, hasChildren, bodyRegistryRef, hiddenBodiesRef, requestBodyReload]);
   useEffect(() => {
     if (status !== "ready") return;
     const model = mjModelRef.current;
@@ -2904,12 +3056,12 @@ function Body({
     if (!hasChildren) return;
     const data = mjDataRef.current;
     const id = bodyIdRef.current;
-    const group = groupRef.current;
-    if (!data || id < 0 || !group) return;
+    const group2 = groupRef.current;
+    if (!data || id < 0 || !group2) return;
     const i3 = id * 3;
     const i4 = id * 4;
-    group.position.set(data.xpos[i3], data.xpos[i3 + 1], data.xpos[i3 + 2]);
-    group.quaternion.set(
+    group2.position.set(data.xpos[i3], data.xpos[i3 + 1], data.xpos[i3 + 2]);
+    group2.quaternion.set(
       data.xquat[i4 + 1],
       data.xquat[i4 + 2],
       data.xquat[i4 + 3],
@@ -3242,24 +3394,35 @@ function useSceneLights(intensity = 1) {
     targetsRef.current = [];
     const nlight = model.nlight ?? 0;
     if (nlight === 0) return;
+    const lightActive = getModelArray(model, "light_active");
+    const lightTypeArray = getModelArray(model, "light_type");
+    const lightCastShadow = getModelArray(model, "light_castshadow");
+    const lightIntensity = getModelArray(model, "light_intensity");
+    const lightDiffuse = getModelArray(model, "light_diffuse");
+    const lightPos = getModelArray(model, "light_pos");
+    const lightDir = getModelArray(model, "light_dir");
+    const lightCutoff = getModelArray(model, "light_cutoff");
+    const lightExponent = getModelArray(model, "light_exponent");
+    const lightAttenuation = getModelArray(model, "light_attenuation");
+    if (!lightPos || !lightDir) return;
     for (let i = 0; i < nlight; i++) {
-      const active = model.light_active ? model.light_active[i] : 1;
+      const active = lightActive ? lightActive[i] : 1;
       if (!active) continue;
-      const lightType = model.light_type ? model.light_type[i] : 0;
+      const lightType = lightTypeArray ? lightTypeArray[i] : 0;
       const isDirectional = lightType === 0;
-      const castShadow = model.light_castshadow ? model.light_castshadow[i] !== 0 : false;
-      const mjIntensity = model.light_intensity ? model.light_intensity[i] : 1;
+      const castShadow = lightCastShadow ? lightCastShadow[i] !== 0 : false;
+      const mjIntensity = lightIntensity ? lightIntensity[i] : 1;
       const finalIntensity = intensity * mjIntensity;
-      const dr = model.light_diffuse ? model.light_diffuse[3 * i] : 1;
-      const dg = model.light_diffuse ? model.light_diffuse[3 * i + 1] : 1;
-      const db = model.light_diffuse ? model.light_diffuse[3 * i + 2] : 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 px = model.light_pos[3 * i];
-      const py = model.light_pos[3 * i + 1];
-      const pz = model.light_pos[3 * i + 2];
-      const dx = model.light_dir[3 * i];
-      const dy = model.light_dir[3 * i + 1];
-      const dz = model.light_dir[3 * i + 2];
+      const px = lightPos[3 * i];
+      const py = lightPos[3 * i + 1];
+      const pz = lightPos[3 * i + 2];
+      const dx = lightDir[3 * i];
+      const dy = lightDir[3 * i + 1];
+      const dz = lightDir[3 * i + 2];
       if (isDirectional) {
         const light = new THREE11.DirectionalLight(color, finalIntensity);
         light.position.set(px, py, pz);
@@ -3281,16 +3444,16 @@ function useSceneLights(intensity = 1) {
         lightsRef.current.push(light);
         targetsRef.current.push(light.target);
       } else {
-        const cutoff = model.light_cutoff ? model.light_cutoff[i] : 45;
-        const exponent = model.light_exponent ? model.light_exponent[i] : 10;
+        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);
         light.position.set(px, py, pz);
         light.target.position.set(px + dx, py + dy, pz + dz);
         light.castShadow = castShadow;
-        if (model.light_attenuation) {
-          const att1 = model.light_attenuation[3 * i + 1];
-          const att2 = model.light_attenuation[3 * i + 2];
+        if (lightAttenuation) {
+          const att1 = lightAttenuation[3 * i + 1];
+          const att2 = lightAttenuation[3 * i + 2];
           light.decay = att2 > 0 ? 2 : att1 > 0 ? 1 : 0;
           light.distance = att1 > 0 ? 1 / att1 : 0;
         }
@@ -3315,6 +3478,17 @@ function useSceneLights(intensity = 1) {
     };
   }, [status, mjModelRef, scene, intensity]);
 }
+function getModelArray(model, key) {
+  try {
+    const value = model[key];
+    return isArrayLikeNumber(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isArrayLikeNumber(value) {
+  return typeof value === "object" && value !== null && "length" in value && typeof value.length === "number";
+}
 // src/components/SceneLights.tsx
 function SceneLights({ intensity = 1 }) {
@@ -4562,22 +4736,25 @@ function useKeyboardTeleop(config) {
   });
 }
 function usePolicy(config) {
-  const { mjModelRef } = useMujocoContext();
   const lastActionTimeRef = useRef(0);
+  const lastObservationRef = useRef(null);
   const lastActionRef = useRef(null);
-  const isRunningRef = useRef(true);
+  const isRunningRef = useRef(config.enabled ?? true);
   const configRef = useRef(config);
   configRef.current = config;
+  isRunningRef.current = config.enabled ?? isRunningRef.current;
   useBeforePhysicsStep((model, data) => {
     if (!isRunningRef.current) return;
     const cfg = configRef.current;
     model.opt?.timestep ?? 2e-3;
     const interval = 1 / cfg.frequency;
     if (data.time - lastActionTimeRef.current >= interval) {
-      const obs = cfg.onObservation(model, data);
-      cfg.onAction(obs, model, data);
+      const observation = cfg.onObservation({ model, data });
+      const action = cfg.infer ? cfg.infer({ observation, model, data }) : observation;
+      cfg.onAction({ action, observation, model, data });
       lastActionTimeRef.current = data.time;
-      lastActionRef.current = obs;
+      lastObservationRef.current = observation;
+      lastActionRef.current = action;
     }
   });
   return {
@@ -4591,6 +4768,9 @@ function usePolicy(config) {
       isRunningRef.current = false;
     },
     get lastObservation() {
+      return lastObservationRef.current;
+    },
+    get lastAction() {
       return lastActionRef.current;
     }
   };
@@ -4787,6 +4967,114 @@ function useVideoRecorder(options = {}) {
     }
   };
 }
+function isTargetRef(target) {
+  return Boolean(target && typeof target === "object" && "current" in target);
+}
+function resolveCanvasTarget(target) {
+  const resolvedTarget = isTargetRef(target) ? target.current : target;
+  if (!resolvedTarget) {
+    throw new Error("No frame capture target is available.");
+  }
+  if (resolvedTarget instanceof HTMLCanvasElement) {
+    return resolvedTarget;
+  }
+  const canvas = resolvedTarget.querySelector("canvas");
+  if (!canvas) {
+    throw new Error("Frame capture target does not contain a canvas.");
+  }
+  return canvas;
+}
+function waitForNextAnimationFrame() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+}
+async function captureFrame(options) {
+  const type = options.type ?? "image/png";
+  const canvas = resolveCanvasTarget(options.target);
+  if (options.waitForAnimationFrame ?? true) {
+    await waitForNextAnimationFrame();
+  }
+  return {
+    canvas,
+    dataUrl: canvas.toDataURL(type, options.quality),
+    type
+  };
+}
+async function captureFrameBlob(options) {
+  const type = options.type ?? "image/png";
+  const canvas = resolveCanvasTarget(options.target);
+  if (options.waitForAnimationFrame ?? true) {
+    await waitForNextAnimationFrame();
+  }
+  const blob = await new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (nextBlob) => {
+        if (nextBlob) {
+          resolve(nextBlob);
+        } else {
+          reject(new Error("Canvas frame capture did not produce a Blob."));
+        }
+      },
+      type,
+      options.quality
+    );
+  });
+  return { canvas, blob, type };
+}
+function useFrameCapture(defaultOptions = {}) {
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const reset = useCallback(() => {
+    setStatus("idle");
+    setError(null);
+  }, []);
+  const capture = useCallback(
+    async (options = {}) => {
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await captureFrame({ ...defaultOptions, ...options });
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to capture the current canvas frame.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [defaultOptions]
+  );
+  const captureBlob = useCallback(
+    async (options = {}) => {
+      setStatus("capturing");
+      setError(null);
+      try {
+        const result = await captureFrameBlob({
+          ...defaultOptions,
+          ...options
+        });
+        setStatus("captured");
+        return result;
+      } catch (nextError) {
+        const error2 = nextError instanceof Error ? nextError : new Error("Unable to capture the current canvas frame.");
+        setError(error2);
+        setStatus("error");
+        throw error2;
+      }
+    },
+    [defaultOptions]
+  );
+  return {
+    status,
+    error,
+    isCapturing: status === "capturing",
+    capture,
+    captureBlob,
+    reset
+  };
+}
 function useCtrlNoise(config = {}) {
   const { mjModelRef } = useMujocoContext();
   const configRef = useRef(config);
@@ -5072,6 +5360,12 @@ function useCameraAnimation() {
  *
  * useVideoRecorder — canvas video recording hook (spec 13.3)
  */
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * useFrameCapture — still-frame capture for canvas-backed MuJoCo/R3F scenes.
+ */
 /**
  * @license
  * SPDX-License-Identifier: Apache-2.0
@@ -5102,6 +5396,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, 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, 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, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map