mujoco-react 9.3.0 → 9.4.0

package/dist/index.js

@@ -1,5 +1,5 @@
-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 { withContacts, getContact } from './chunk-VDSEPZYQ.js';
+export { RobotActuators, RobotBodies, RobotCameras, RobotGeoms, RobotJoints, RobotKeyframes, RobotResources, RobotSensors, RobotSites, ScenarioLighting, SplatEnvironment, SplatEnvironmentReadinessStatus, VisualScenarioEffects, createPairedSplatEnvironment, createSparkSplatViewerUrl, createSplatEnvironmentUserData, createSplatSceneConfig, createVisualScenarioExecutionContext, getContact, getScenarioBackground, getScenarioCameraPosition, getSplatEnvironmentReadiness, registerRobotResources, useSplatEnvironment, useSplatSceneConfig, useVisualScenarioEffects, useVisualScenarioExecutionContext, withSplatEnvironment } from './chunk-VDSEPZYQ.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';
@@ -1578,11 +1578,24 @@ async function captureCameraFrameBlob(renderer, scene, fallbackCamera, options =
 }
 
 // src/rendering/cameraFrameSource.ts
+var MountedCameraFrameSourceSuggestionMatch = {
+  Direct: "direct",
+  Alias: "alias",
+  Normalized: "normalized",
+  Prefix: "prefix",
+  Suffix: "suffix",
+  Contains: "contains"
+};
 var MountedCameraFrameSequenceReadinessStatus = {
   Ready: "ready",
   Partial: "partial",
   Missing: "missing"
 };
+var MountedCameraFrameSequenceManifestStatus = {
+  Complete: "complete",
+  Partial: "partial",
+  Missing: "missing"
+};
 function getResourceName(resource) {
   if (!resource) return null;
   return typeof resource === "string" ? resource : resource.name ?? null;
@@ -1592,6 +1605,9 @@ function createNameSet(resources) {
     (resources ?? []).map((resource) => getResourceName(resource)).filter((name) => Boolean(name))
   );
 }
+function createResourceNames(resources) {
+  return (resources ?? []).map((resource) => getResourceName(resource)).filter((name) => Boolean(name));
+}
 function normalizeAliasCandidates(value) {
   if (!value) return [];
   return Array.isArray(value) ? value : [value];
@@ -1599,6 +1615,24 @@ function normalizeAliasCandidates(value) {
 function countMountedSelectors(selector) {
   return Number(Boolean(selector.cameraName)) + Number(Boolean(selector.siteName)) + Number(Boolean(selector.bodyName));
 }
+function normalizeCameraSourceName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function createCameraSourceKeyVariants(key) {
+  const candidates = [
+    key,
+    key.startsWith("observation.images.") ? key.slice("observation.images.".length) : "",
+    key.includes(".") ? key.split(".").at(-1) ?? "" : "",
+    key.includes("/") ? key.split("/").at(-1) ?? "" : ""
+  ];
+  return candidates.map((candidate) => candidate.trim()).filter((candidate, index, items) => candidate && items.indexOf(candidate) === index);
+}
+function getSelectorKey(selector) {
+  if (selector.cameraName) return `camera:${selector.cameraName}`;
+  if (selector.siteName) return `site:${selector.siteName}`;
+  if (selector.bodyName) return `body:${selector.bodyName}`;
+  return null;
+}
 function getMountedCameraFrameCaptureSource(selector) {
   if (countMountedSelectors(selector) !== 1) return null;
   if (selector.cameraName) {
@@ -1623,10 +1657,119 @@ function getCameraFrameCaptureSourceTarget(source) {
   if (source.kind === "explicit-pose") return "explicit pose";
   return "fallback camera";
 }
+function createMountedCameraFrameSourceSuggestion(key, selector, resourceName, match) {
+  const source = getMountedCameraFrameCaptureSource(selector);
+  if (!source) return null;
+  return {
+    key,
+    selector,
+    source,
+    resourceName,
+    resourceKind: source.kind,
+    match
+  };
+}
+function addMountedCameraFrameSourceSuggestion(suggestions, seen, suggestion) {
+  if (!suggestion) return;
+  const selectorKey = getSelectorKey(suggestion.selector);
+  if (!selectorKey || seen.has(selectorKey)) return;
+  seen.add(selectorKey);
+  suggestions.push(suggestion);
+}
+function getCameraFrameResourceMatch(key, resourceName) {
+  if (resourceName === key) return MountedCameraFrameSourceSuggestionMatch.Direct;
+  const normalizedResource = normalizeCameraSourceName(resourceName);
+  if (!normalizedResource) return null;
+  for (const variant of createCameraSourceKeyVariants(key)) {
+    if (resourceName === variant) return MountedCameraFrameSourceSuggestionMatch.Direct;
+    const normalizedKey = normalizeCameraSourceName(variant);
+    if (!normalizedKey) continue;
+    if (normalizedResource === normalizedKey) {
+      return MountedCameraFrameSourceSuggestionMatch.Normalized;
+    }
+    if (normalizedResource.startsWith(`${normalizedKey}_`)) {
+      return MountedCameraFrameSourceSuggestionMatch.Prefix;
+    }
+    if (normalizedResource.endsWith(`_${normalizedKey}`)) {
+      return MountedCameraFrameSourceSuggestionMatch.Suffix;
+    }
+    if (normalizedResource.includes(`_${normalizedKey}_`)) {
+      return MountedCameraFrameSourceSuggestionMatch.Contains;
+    }
+  }
+  return null;
+}
 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 createMountedCameraFrameSourceSuggestions(key, options) {
+  const cameraNames = createNameSet(options.cameras);
+  const siteNames = createNameSet(options.sites);
+  const bodyNames = createNameSet(options.bodies);
+  const suggestions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const selector of normalizeAliasCandidates(options.aliases?.[key])) {
+    if (!isSelectorMounted(selector, cameraNames, siteNames, bodyNames)) {
+      continue;
+    }
+    const source = getMountedCameraFrameCaptureSource(selector);
+    if (!source) continue;
+    addMountedCameraFrameSourceSuggestion(
+      suggestions,
+      seen,
+      createMountedCameraFrameSourceSuggestion(
+        key,
+        selector,
+        getCameraFrameCaptureSourceTarget(source),
+        MountedCameraFrameSourceSuggestionMatch.Alias
+      )
+    );
+  }
+  for (const cameraName of createResourceNames(options.cameras)) {
+    const match = getCameraFrameResourceMatch(key, cameraName);
+    if (!match) continue;
+    addMountedCameraFrameSourceSuggestion(
+      suggestions,
+      seen,
+      createMountedCameraFrameSourceSuggestion(
+        key,
+        { cameraName },
+        cameraName,
+        match
+      )
+    );
+  }
+  for (const siteName of createResourceNames(options.sites)) {
+    const match = getCameraFrameResourceMatch(key, siteName);
+    if (!match) continue;
+    addMountedCameraFrameSourceSuggestion(
+      suggestions,
+      seen,
+      createMountedCameraFrameSourceSuggestion(
+        key,
+        { siteName },
+        siteName,
+        match
+      )
+    );
+  }
+  for (const bodyName of createResourceNames(options.bodies)) {
+    const match = getCameraFrameResourceMatch(key, bodyName);
+    if (!match) continue;
+    addMountedCameraFrameSourceSuggestion(
+      suggestions,
+      seen,
+      createMountedCameraFrameSourceSuggestion(
+        key,
+        { bodyName },
+        bodyName,
+        match
+      )
+    );
+  }
+  return suggestions;
+}
 function resolveMountedCameraFrameSource(key, options) {
   const cameraNames = createNameSet(options.cameras);
   const siteNames = createNameSet(options.sites);
@@ -1646,6 +1789,14 @@ function resolveMountedCameraFrameSource(key, options) {
     if (!source) continue;
     return { key, selector, source };
   }
+  const [suggestion] = createMountedCameraFrameSourceSuggestions(key, options);
+  if (suggestion) {
+    return {
+      key,
+      selector: suggestion.selector,
+      source: suggestion.source
+    };
+  }
   if (options.allowAliasFallback) {
     for (const selector of aliasCandidates) {
       const source = getMountedCameraFrameCaptureSource(selector);
@@ -1716,6 +1867,77 @@ function createMountedCameraFrameSequenceReadiness(plan) {
     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 normalizeFrameCount(frameCount) {
+  return Number.isFinite(frameCount) && frameCount !== void 0 ? Math.max(0, Math.floor(frameCount)) : 0;
+}
+function createMountedCameraFrameSequenceManifest(result, options = {}) {
+  const cameraKeys = [
+    ...options.cameraKeys ?? result.readiness.cameraKeys ?? result.plan.cameraKeys ?? result.cameraKeys
+  ];
+  const expectedFrameCount = normalizeFrameCount(
+    options.expectedFrameCount ?? result.frameCount
+  );
+  const recordedFrameCount = normalizeFrameCount(result.frameCount);
+  const streamSummaries = {};
+  const streams = [];
+  let missingFrameCount = 0;
+  let completeStreamCount = 0;
+  let resolvedOrRecordedStreamCount = 0;
+  for (const key of cameraKeys) {
+    const summary = result.cameraSummaries[key];
+    const readiness = result.readiness.cameras[key];
+    const source = summary?.source ?? readiness?.source;
+    const ready = readiness?.ready ?? Boolean(summary);
+    const recorded = normalizeFrameCount(summary?.frameCount);
+    const missing = Math.max(expectedFrameCount - recorded, 0);
+    const complete2 = ready && missing === 0;
+    const status2 = complete2 ? MountedCameraFrameSequenceManifestStatus.Complete : ready || recorded > 0 ? MountedCameraFrameSequenceManifestStatus.Partial : MountedCameraFrameSequenceManifestStatus.Missing;
+    const target = source ? getCameraFrameCaptureSourceTarget(source) : readiness?.message ? void 0 : "missing MuJoCo camera";
+    const message = complete2 ? `Camera stream "${key}" recorded ${recorded} of ${expectedFrameCount} frame${expectedFrameCount === 1 ? "" : "s"}.` : ready || recorded > 0 ? `Camera stream "${key}" recorded ${recorded} of ${expectedFrameCount} frame${expectedFrameCount === 1 ? "" : "s"}.` : readiness?.message ?? `Camera stream "${key}" did not record any frames.`;
+    const stream = {
+      key,
+      ready,
+      complete: complete2,
+      status: status2,
+      source,
+      selector: readiness?.selector,
+      target,
+      width: summary?.width,
+      height: summary?.height,
+      expectedFrameCount,
+      recordedFrameCount: recorded,
+      missingFrameCount: missing,
+      firstFrameIndex: summary?.firstFrameIndex ?? null,
+      lastFrameIndex: summary?.lastFrameIndex ?? null,
+      firstTimestamp: summary?.firstTimestamp ?? null,
+      lastTimestamp: summary?.lastTimestamp ?? null,
+      message
+    };
+    streamSummaries[key] = stream;
+    streams.push(stream);
+    missingFrameCount += missing;
+    if (complete2) completeStreamCount += 1;
+    if (ready || recorded > 0) resolvedOrRecordedStreamCount += 1;
+  }
+  const complete = result.readiness.ready && streams.length === completeStreamCount && missingFrameCount === 0;
+  const status = complete ? MountedCameraFrameSequenceManifestStatus.Complete : resolvedOrRecordedStreamCount > 0 ? MountedCameraFrameSequenceManifestStatus.Partial : MountedCameraFrameSequenceManifestStatus.Missing;
+  return {
+    schema: "mujoco-react/mounted-camera-frame-sequence-manifest@1",
+    ready: result.readiness.ready,
+    complete,
+    status,
+    cameraKeys,
+    resolvedKeys: [...result.readiness.resolvedKeys],
+    missingKeys: [...result.readiness.missingKeys],
+    expectedFrameCount,
+    recordedFrameCount,
+    missingFrameCount,
+    streamSummaries,
+    streams,
+    readiness: result.readiness,
+    message: complete ? `All ${cameraKeys.length} camera stream${cameraKeys.length === 1 ? "" : "s"} recorded ${expectedFrameCount} frame${expectedFrameCount === 1 ? "" : "s"}.` : `Mounted camera sequence coverage is ${status}.`
+  };
+}
 function createMountedCameraFrameSequencePlanFromApi(api, cameraKeys, options = {}) {
   return createMountedCameraFrameSequencePlan(cameraKeys, {
     ...options,
@@ -2948,7 +3170,7 @@ function MujocoSimProvider({
           }
           const frame = {
             frameIndex,
-            time: getTime(),
+            time: data.time,
             cameras: cameraFrames
           };
           if (retainFrames) {
@@ -4345,6 +4567,231 @@ function SceneLights({ intensity = 1 }) {
   useSceneLights(intensity);
   return null;
 }
+function SplatCollisionProxyPreview({
+  collisionProxy,
+  xmlText,
+  fetchXml = fetchSplatCollisionProxyXml,
+  color = "#60a5fa",
+  opacity = 0.12,
+  planeColor = "#94a3b8",
+  planeOpacity = 0.08,
+  children,
+  ...groupProps
+}) {
+  const { geoms } = useSplatCollisionProxyGeoms({
+    collisionProxy,
+    xmlText,
+    fetchXml
+  });
+  if (geoms.length === 0 && !children) return null;
+  return /* @__PURE__ */ jsxs(
+    "group",
+    {
+      ...groupProps,
+      userData: {
+        kind: "splat-collision-proxy-preview",
+        ...groupProps.userData
+      },
+      children: [
+        geoms.map((geom) => /* @__PURE__ */ jsx(
+          SplatCollisionProxyGeom,
+          {
+            geom,
+            color,
+            opacity,
+            planeColor,
+            planeOpacity
+          },
+          geom.id
+        )),
+        children
+      ]
+    }
+  );
+}
+function useSplatCollisionProxyGeoms({
+  collisionProxy,
+  xmlText,
+  fetchXml = fetchSplatCollisionProxyXml,
+  enabled = true
+}) {
+  const [loadedXmlText, setLoadedXmlText] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const xmlPath = collisionProxy?.xmlPath;
+  useEffect(() => {
+    let cancelled = false;
+    if (!enabled) {
+      setLoadedXmlText(null);
+      setStatus("idle");
+      setError(null);
+      return void 0;
+    }
+    if (xmlText) {
+      setLoadedXmlText(xmlText);
+      setStatus("ready");
+      setError(null);
+      return void 0;
+    }
+    if (!xmlPath || !canFetchSplatCollisionProxyXml(xmlPath)) {
+      setLoadedXmlText(null);
+      setStatus("idle");
+      setError(null);
+      return void 0;
+    }
+    const fetchPath = xmlPath;
+    async function loadProxyXml() {
+      setStatus("loading");
+      setError(null);
+      try {
+        const nextXmlText = await fetchXml(fetchPath);
+        if (!cancelled) {
+          setLoadedXmlText(nextXmlText);
+          setStatus("ready");
+        }
+      } catch (nextError) {
+        if (!cancelled) {
+          setLoadedXmlText(null);
+          setStatus("error");
+          setError(
+            nextError instanceof Error ? nextError : new Error("Unable to load collision proxy XML.")
+          );
+        }
+      }
+    }
+    void loadProxyXml();
+    return () => {
+      cancelled = true;
+    };
+  }, [enabled, fetchXml, xmlPath, xmlText]);
+  const geoms = useMemo(
+    () => loadedXmlText ? parseSplatCollisionProxyGeoms(loadedXmlText) : [],
+    [loadedXmlText]
+  );
+  return useMemo(
+    () => ({
+      geoms,
+      status,
+      error,
+      xmlPath
+    }),
+    [error, geoms, status, xmlPath]
+  );
+}
+async function fetchSplatCollisionProxyXml(xmlPath) {
+  const response = await fetch(xmlPath);
+  if (!response.ok) {
+    throw new Error(`Unable to load collision proxy XML (${response.status}).`);
+  }
+  return response.text();
+}
+function canFetchSplatCollisionProxyXml(xmlPath) {
+  return xmlPath.startsWith("/") || xmlPath.startsWith("http://") || xmlPath.startsWith("https://");
+}
+function parseSplatCollisionProxyGeoms(xmlText) {
+  const parser = typeof DOMParser === "undefined" ? null : new DOMParser();
+  if (!parser) return [];
+  const document2 = parser.parseFromString(xmlText, "application/xml");
+  if (document2.querySelector("parsererror")) return [];
+  const bodyPositions = /* @__PURE__ */ new Map();
+  for (const body of Array.from(document2.querySelectorAll("body"))) {
+    const parentBody = body.parentElement?.closest("body");
+    const parentPosition = parentBody ? bodyPositions.get(parentBody) ?? [0, 0, 0] : [0, 0, 0];
+    bodyPositions.set(
+      body,
+      addProxyVectors(parentPosition, parseProxyVector(body.getAttribute("pos")))
+    );
+  }
+  return Array.from(document2.querySelectorAll("geom")).map((geom, index) => {
+    const type = getCollisionProxyGeomType(geom);
+    if (!type) return null;
+    const parentBody = geom.closest("body");
+    const bodyPosition = parentBody ? bodyPositions.get(parentBody) ?? [0, 0, 0] : [0, 0, 0];
+    const position = addProxyVectors(
+      bodyPosition,
+      parseProxyVector(geom.getAttribute("pos"))
+    );
+    const size = parseNumberList(geom.getAttribute("size"));
+    return {
+      id: geom.getAttribute("name") ?? `${type}-${index}`,
+      type,
+      position,
+      size
+    };
+  }).filter((geom) => Boolean(geom));
+}
+function SplatCollisionProxyGeom({
+  geom,
+  color,
+  opacity,
+  planeColor,
+  planeOpacity
+}) {
+  if (geom.type === "sphere") {
+    return /* @__PURE__ */ jsxs("mesh", { position: geom.position, children: [
+      /* @__PURE__ */ jsx("sphereGeometry", { args: [geom.size[0] ?? 0.1, 16, 8] }),
+      /* @__PURE__ */ jsx(SplatCollisionProxyMaterial, { color, opacity })
+    ] });
+  }
+  if (geom.type === "plane") {
+    const width = geom.size[0] && geom.size[0] > 0 ? geom.size[0] * 2 : 4;
+    const height = geom.size[1] && geom.size[1] > 0 ? geom.size[1] * 2 : 4;
+    return /* @__PURE__ */ jsxs("mesh", { position: geom.position, children: [
+      /* @__PURE__ */ jsx("boxGeometry", { args: [width, height, 0.02] }),
+      /* @__PURE__ */ jsx(SplatCollisionProxyMaterial, { color: planeColor, opacity: planeOpacity })
+    ] });
+  }
+  const size = getCollisionProxyBoxSize(geom);
+  return /* @__PURE__ */ jsxs("mesh", { position: geom.position, children: [
+    /* @__PURE__ */ jsx("boxGeometry", { args: size }),
+    /* @__PURE__ */ jsx(SplatCollisionProxyMaterial, { color, opacity })
+  ] });
+}
+function SplatCollisionProxyMaterial({
+  color,
+  opacity
+}) {
+  return /* @__PURE__ */ jsx(
+    "meshBasicMaterial",
+    {
+      color,
+      transparent: true,
+      opacity,
+      wireframe: true
+    }
+  );
+}
+function getCollisionProxyGeomType(geom) {
+  const type = geom.getAttribute("type") ?? "sphere";
+  if (type === "box" || type === "plane" || type === "sphere" || type === "capsule" || type === "mesh") {
+    return type;
+  }
+  return null;
+}
+function getCollisionProxyBoxSize(geom) {
+  if (geom.type === "capsule") {
+    const radius = geom.size[0] ?? 0.05;
+    const halfLength = geom.size[1] ?? radius;
+    return [radius * 2, radius * 2, Math.max(radius * 2, halfLength * 2)];
+  }
+  if (geom.type === "mesh") return [0.2, 0.2, 0.2];
+  return [
+    (geom.size[0] ?? 0.1) * 2,
+    (geom.size[1] ?? geom.size[0] ?? 0.1) * 2,
+    (geom.size[2] ?? geom.size[0] ?? 0.1) * 2
+  ];
+}
+function parseProxyVector(value) {
+  const values = parseNumberList(value);
+  return [values[0] ?? 0, values[1] ?? 0, values[2] ?? 0];
+}
+function parseNumberList(value) {
+  if (!value) return [];
+  return value.trim().split(/\s+/).map((part) => Number(part)).filter((part) => Number.isFinite(part));
+}
+function addProxyVectors(a, b) {
+  return [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+}
 var JOINT_COLORS = {
   0: 16711680,
   // free - red
@@ -5923,22 +6370,46 @@ function useMountedCameraSequenceRecorder(defaultOptions = {}) {
   const mujoco = useMujoco();
   const [status, setStatus] = useState("idle");
   const [error, setError] = useState(null);
+  const [plan, setPlan] = useState(null);
+  const [readiness, setReadiness] = useState(null);
+  const [result, setResult] = useState(
+    null
+  );
   const reset = useCallback(() => {
     setStatus("idle");
     setError(null);
+    setPlan(null);
+    setReadiness(null);
+    setResult(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
-      });
+      const nextPlan = createMountedCameraFrameSequencePlanFromApi(
+        mujoco.api,
+        cameraKeys,
+        {
+          ...defaultOptions,
+          ...options
+        }
+      );
+      setPlan(nextPlan);
+      setReadiness(null);
+      return nextPlan;
     },
     [defaultOptions, mujoco.api]
   );
+  const checkReadiness = useCallback(
+    (cameraKeys, options = {}) => {
+      const nextPlan = createPlan(cameraKeys, options);
+      const nextReadiness = createMountedCameraFrameSequenceReadiness(nextPlan);
+      setReadiness(nextReadiness);
+      return nextReadiness;
+    },
+    [createPlan]
+  );
   const record = useCallback(
     async (options) => {
       if (!mujoco.api) {
@@ -5946,13 +6417,17 @@ function useMountedCameraSequenceRecorder(defaultOptions = {}) {
       }
       setStatus("capturing");
       setError(null);
+      setResult(null);
       try {
-        const result = await recordMountedCameraFrameSequence(mujoco.api, {
+        const nextResult = await recordMountedCameraFrameSequence(mujoco.api, {
           ...defaultOptions,
           ...options
         });
+        setPlan(nextResult.plan);
+        setReadiness(nextResult.readiness);
+        setResult(nextResult);
         setStatus("captured");
-        return result;
+        return nextResult;
       } catch (nextError) {
         const error2 = nextError instanceof Error ? nextError : new Error("Unable to record the requested mounted camera sequence.");
         setError(error2);
@@ -5965,8 +6440,12 @@ function useMountedCameraSequenceRecorder(defaultOptions = {}) {
   return {
     status,
     error,
+    plan,
+    readiness,
+    result,
     isRecording: status === "capturing",
     createPlan,
+    checkReadiness,
     record,
     reset
   };
@@ -6322,6 +6801,6 @@ function useCameraAnimation() {
  * useCameraAnimation — composable camera animation hook.
  */
 
-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 };
+export { Body, ContactListener, ContactMarkers, Debug, DragInteraction, FlexRenderer, IkGizmo, InstancedGeomRenderer, MountedCameraFrameSequenceManifestStatus, MountedCameraFrameSequenceReadinessStatus, MountedCameraFrameSourceSuggestionMatch, MujocoCanvas, MujocoPhysics, MujocoProvider, MujocoSimProvider, SceneLights, SplatCollisionProxyPreview, TendonRenderer, TrajectoryPlayer, buildObservation, canFetchSplatCollisionProxyXml, captureCameraFrame, captureCameraFrameBlob, captureFrame, captureFrameBlob, createCameraFrameCaptureSession, createContiguousControlGroup, createController, createControllerHook, createMountedCameraFrameSequenceManifest, createMountedCameraFrameSequencePlan, createMountedCameraFrameSequencePlanFromApi, createMountedCameraFrameSequenceReadiness, createMountedCameraFrameSourceSuggestions, fetchSplatCollisionProxyXml, findActuatorByName, findBodyByName, findGeomByName, findJointByName, findKeyframeByName, findSensorByName, findSiteByName, findTendonByName, getActuatedJoints, getCameraFrameCaptureSourceTarget, getControlMap, getMountedCameraFrameCaptureSource, getName, isMountedCameraFrameCaptureSource, loadScene, parseSplatCollisionProxyGeoms, 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, useSplatCollisionProxyGeoms, useTrajectoryPlayer, useTrajectoryRecorder, useVideoRecorder };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map