mujoco-react 9.2.0 → 9.4.0

package/README.md

@@ -143,7 +143,7 @@ Use it as a child of `<MujocoCanvas>`:
 
 ## Gaussian Splat Environments
 
-Gaussian splats are visual context; MuJoCo XML remains the source of physics, contacts, and task fixtures. Pair each splat asset with collision proxy metadata so scene variants, rollouts, and datasets preserve both sides of the environment.
+Gaussian splats are visual context; MuJoCo XML remains the source of physics, contacts, and task fixtures. Use visual-only splats when you only need rendered environment context, and add collision proxy metadata when a workflow needs simplified contact geometry.
 
 Use `VisualScenarioEffects` when the same MuJoCo task should render under
 different camera exposure, fog/background, and deterministic material variants:
@@ -162,16 +162,102 @@ import { ScenarioLighting, VisualScenarioEffects } from "mujoco-react";
 
 Use the renderer-agnostic boundary from the main package. If your app stores
 visual scenarios as data, pass the scenario directly; the component resolves the
-splat asset and paired MJCF collision proxy metadata for you.
+splat asset and any paired MJCF collision proxy metadata for you. Visual-only
+splats are valid, and readiness tells you whether a collision proxy is required
+for your training/physics handoff.
 
 ```tsx
-import { SplatEnvironment, withSplatEnvironment } from "mujoco-react";
+import { MujocoCanvas, SplatEnvironment, useSplatSceneConfig } from "mujoco-react";
 
-<SplatEnvironment scenario={scenario} renderer="custom" />;
+const splat = useSplatSceneConfig({ sceneConfig, scenario });
+
+<MujocoCanvas config={splat.sceneConfig}>
+  {splat.environment ? (
+    <SplatEnvironment environment={splat.environment} renderer="custom">
+      <MySplatRenderer src={splat.environment.splat.src} />
+    </SplatEnvironment>
+  ) : null}
+</MujocoCanvas>;
+```
+
+When a splat scenario includes paired MJCF collision proxy metadata, render a
+generic wireframe preview from that XML with `SplatCollisionProxyPreview`. The
+component parses MJCF primitives such as planes, boxes, spheres, capsules, and
+mesh placeholders from any fetchable proxy XML; the tabletop example is just one
+possible environment.
+
+```tsx
+import {
+  SplatCollisionProxyPreview,
+  SplatEnvironment,
+  useSplatCollisionProxyGeoms,
+  useSplatSceneConfig,
+} from "mujoco-react";
+
+const splat = useSplatSceneConfig({ sceneConfig, scenario });
+const proxy = splat.environment?.collisionProxy;
+
+<SplatEnvironment
+  environment={splat.environment}
+  collisionProxy={
+    proxy ? <SplatCollisionProxyPreview collisionProxy={proxy} /> : undefined
+  }
+/>;
+```
+
+Use `useSplatCollisionProxyGeoms()` when your app wants to inspect or style the
+proxy primitives itself:
+
+```tsx
+const proxyPreview = useSplatCollisionProxyGeoms({
+  collisionProxy: splat.environment?.collisionProxy,
+});
+
+proxyPreview.geoms.map((geom) => geom.type);
 ```
 
-For MuJoCo + 3DGS composition, derive the collision environment from the same
-splat metadata and pass the resulting config to `<MujocoCanvas>`:
+Use `splat.readiness` or `getSplatEnvironmentReadiness(scenario)` to gate
+authoring and import flows. The status distinguishes disabled scenarios,
+missing visual assets, missing collision proxies, unsupported renderer formats,
+and ready environments.
+
+Use `createSplatSceneConfig()` when the same scene composition needs to run
+outside React, such as codegen, import validation, backend handoff metadata, or
+tests:
+
+```tsx
+import { createSplatSceneConfig } from "mujoco-react";
+
+const splat = createSplatSceneConfig({
+  sceneConfig,
+  scenario,
+  renderer: "spark",
+});
+```
+
+Use `createVisualScenarioExecutionContext()` or
+`useVisualScenarioExecutionContext()` when recording rollouts or exporting
+LeRobot/HF Jobs handoff artifacts. It resolves the scenario seed, camera
+exposure/noise/blur/jitter, material randomization, splat source, collision
+proxy, and readiness into one serializable object.
+
+```tsx
+import { createVisualScenarioExecutionContext } from "mujoco-react";
+
+const visualContext = createVisualScenarioExecutionContext({
+  scenario,
+  renderer: "spark",
+  variantId,
+});
+
+writeEpisodeManifest({
+  task,
+  visualExecutionContext: visualContext,
+});
+```
+
+For MuJoCo + 3DGS composition, derive the optional collision environment from
+the same splat metadata and pass the resulting config to `<MujocoCanvas>`:
 
 ```tsx
 const sceneConfig = withSplatEnvironment(
@@ -192,16 +278,18 @@ npm install @sparkjsdev/spark
 ```tsx
 import {
   SparkSplatEnvironment,
-  useSparkSplatLifecycle,
+  useSparkSplatEnvironment,
 } from "mujoco-react/spark";
 
 function Scene() {
-  const splat = useSparkSplatLifecycle();
+  const splat = useSparkSplatEnvironment({ sceneConfig, scenario });
 
   return (
-    <MujocoCanvas config={sceneConfig} gl={{ preserveDrawingBuffer: true }}>
-      <SparkSplatEnvironment scenario={scenario} hideGroundMeshes {...splat.props} />
-      <StatusBadge status={splat.status} error={splat.error} />
+    <MujocoCanvas config={splat.sceneConfig} gl={{ preserveDrawingBuffer: true }}>
+      {splat.environment ? (
+        <SparkSplatEnvironment hideGroundMeshes {...splat.props} />
+      ) : null}
+      <StatusBadge status={splat.lifecycle.status} error={splat.lifecycle.error} />
     </MujocoCanvas>
   );
 }
@@ -537,7 +625,7 @@ interface SceneConfig {
 }
 ```
 
-Use `environmentFiles` to compose reusable physics/collision layers with a robot model. For Gaussian splat scenes, keep the `.spz` as a parallel visual layer and point `environmentFiles` at the paired MJCF proxy scene:
+Use `environmentFiles` to compose reusable physics/collision layers with a robot model. For Gaussian splat scenes, keep the `.spz` as a parallel visual layer and point `environmentFiles` at a paired MJCF proxy scene only when contact geometry is needed:
 
 ```tsx
 const kitchenRobot: SceneConfig = {
@@ -1009,11 +1097,133 @@ Use `useFrameCapture()` or the standalone `captureFrame()` helpers when you own
 the canvas or want to capture a custom container.
 
 Use `captureCameraFrame()` / `captureCameraFrameBlob()` when dataset generation
-needs a fixed offscreen camera pose or resolution without moving the user's
-interactive viewport.
+needs an offscreen camera render at a stable resolution without moving the
+user's interactive viewport. Pass `cameraName`, `siteName`, or `bodyName` to
+record true MuJoCo-mounted camera frames; the returned image includes
+`source.kind` so dataset pipelines can reject fallback or synthetic fixed poses.
 
 Use `recordCameraSequence()` / `useCameraSequenceRecorder()` to step policy
-rollouts and capture synchronized frames from one or more fixed camera configs.
+rollouts and capture synchronized per-camera frames from one or more MuJoCo
+camera configs. Sequence recording requires mounted MuJoCo camera, site, or
+body selectors by default; use still capture APIs for synthetic debug poses.
+
+For LeRobot-style datasets, prefer the named-camera wrapper. It resolves task
+camera keys to MuJoCo cameras/sites/bodies, records the sequence, and returns
+the plan and readiness summary alongside frame provenance:
+
+```tsx
+const sequence = await recordMountedCameraFrameSequence(api, {
+  cameraKeys: ["head", "left_wrist", "right_wrist"],
+  aliases: {
+    head: [{ siteName: "head_camera_rgb_optical_frame" }],
+    left_wrist: [{ siteName: "left_wrist_camera_optical_frame" }],
+    right_wrist: [{ siteName: "right_wrist_camera_optical_frame" }],
+  },
+  defaults: {
+    width: 640,
+    height: 480,
+    type: "image/png",
+    fov: 45,
+    near: 0.01,
+    far: 100,
+  },
+  frames: 16,
+  stepsPerFrame: 1,
+  retainFrames: false,
+  requireMountedSources: true,
+  onFrame: ({ frameIndex, cameras }) => {
+    queueLeRobotImages(frameIndex, cameras);
+  },
+});
+
+sequence.readiness.ready; // true when every requested stream resolved
+sequence.plan.missingKeys; // unresolved task cameras, if requireAll is false
+sequence.cameraSummaries.head.source; // mounted source provenance
+
+const manifest = createMountedCameraFrameSequenceManifest(sequence);
+manifest.streamSummaries.head.complete; // per-camera frame coverage
+manifest.status; // "complete", "partial", or "missing"
+```
+
+`recordMountedCameraFrameSequence()` requires all requested `cameraKeys` by
+default so dataset recording cannot silently omit a camera stream. Set
+`requireAll: false` only for exploratory tooling that can tolerate partial
+camera coverage.
+
+Use `createMountedCameraFrameSequenceManifest()` after recording to persist a
+stable dataset-facing manifest with readiness, source targets, dimensions,
+first/last frame indices, timestamps, and per-camera missing-frame counts.
+
+Inside `<MujocoCanvas>` children, `useMountedCameraSequenceRecorder()` exposes
+the same planning and recording surface with React status/error/result state.
+Use `checkReadiness()` before recording when the UI needs a preflight gate for
+LeRobot camera streams:
+
+```tsx
+function DatasetRecorder() {
+  const recorder = useMountedCameraSequenceRecorder({
+    defaults: { width: 640, height: 480, type: "image/png" },
+    aliases: {
+      head: { cameraName: "head" },
+      left_wrist: { siteName: "left_wrist_camera_optical_frame" },
+      right_wrist: { siteName: "right_wrist_camera_optical_frame" },
+    },
+  });
+
+  async function recordDatasetEpisode() {
+    const cameraKeys = ["head", "left_wrist", "right_wrist"];
+    const readiness = recorder.checkReadiness(cameraKeys);
+    if (!readiness.ready) return;
+
+    await recorder.record({
+      cameraKeys,
+      frames: 16,
+      retainFrames: false,
+      onFrame: ({ frameIndex, cameras }) => {
+        queueLeRobotImages(frameIndex, cameras);
+      },
+    });
+  }
+
+  return (
+    <button disabled={recorder.isRecording} onClick={recordDatasetEpisode}>
+      Record camera streams
+    </button>
+  );
+}
+```
+
+`recorder.readiness` keeps the latest preflight result, and
+`recorder.result?.readiness` keeps the readiness that shipped with the most
+recent recording.
+
+Use `resolveMountedCameraFrameSource()` when dataset feature names need to map
+to named MuJoCo cameras, sites, or bodies before recording. The helper first
+checks exact names and aliases, then falls back to normalized/prefix/suffix
+matches such as `left_wrist` -> `left_wrist_camera_optical_frame`, and
+token-contained imported-model names such as `observation.images.head` ->
+`robot_head_camera`. It returns both the capture selector and the
+mounted-source provenance that should be stored beside the dataset:
+
+```tsx
+const resolved = resolveMountedCameraFrameSource("head", {
+  cameras: api.getCameras(),
+  sites: api.getSites(),
+  bodies: api.getBodies(),
+});
+
+if (!resolved) throw new Error("head does not resolve to a MuJoCo source");
+
+await api.recordCameraSequence({
+  frames: 16,
+  requireMountedSources: true,
+  cameras: [{ key: "head", width: 640, height: 480, ...resolved.selector }],
+});
+```
+
+Pass `aliases` when multiple MuJoCo resources could match a dataset stream key
+or when the model uses names that do not share a normalized prefix/suffix with
+the LeRobot camera feature.
 
 ### `useCtrlNoise(config)`
 

package/dist/{chunk-33CV6HSV.js → chunk-VDSEPZYQ.js}

@@ -1,9 +1,90 @@
 import { useThree } from '@react-three/fiber';
-import { useEffect, useMemo } from 'react';
+import { useMemo, useEffect } from 'react';
 import * as THREE from 'three';
 import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 
-// src/components/VisualScenario.tsx
+// src/types.ts
+var runtimeRobotResources = {};
+var REGISTER_RESOURCE_KEYS = ["actuators", "sensors", "bodies", "joints", "sites", "geoms", "keyframes", "cameras"];
+function createEmptyRuntimeResources() {
+  return {
+    actuators: {},
+    sensors: {},
+    bodies: {},
+    joints: {},
+    sites: {},
+    geoms: {},
+    keyframes: {},
+    cameras: {}
+  };
+}
+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");
+var RobotCameras = createResourceCategory("cameras");
+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 SplatEnvironmentReadinessStatus = {
+  Disabled: "disabled",
+  MissingSplat: "missing-splat",
+  MissingCollisionProxy: "missing-collision-proxy",
+  UnsupportedFormat: "unsupported-format",
+  Ready: "ready"
+};
 var DEFAULT_BACKGROUND = "#181a1f";
 function ScenarioLighting({
   preset = "studio",
@@ -79,6 +160,75 @@ function getScenarioCameraPosition(basePosition, scenario) {
     Number((z + jitter * 0.25).toFixed(3))
   ];
 }
+function useVisualScenarioExecutionContext({
+  scenario,
+  environment,
+  renderer,
+  variantId,
+  enabled
+}) {
+  return useMemo(
+    () => createVisualScenarioExecutionContext({
+      scenario,
+      environment,
+      renderer,
+      variantId,
+      enabled
+    }),
+    [enabled, environment, renderer, scenario, variantId]
+  );
+}
+function createVisualScenarioExecutionContext({
+  scenario,
+  environment,
+  renderer,
+  variantId,
+  enabled = true
+}) {
+  const pairedEnvironment = environment ?? (scenario ? createPairedSplatEnvironment(scenario, { renderer }) : void 0);
+  const splat = scenario?.splat;
+  const collisionProxy = pairedEnvironment?.collisionProxy ?? splat?.collisionProxy ?? void 0;
+  const readiness = getSplatEnvironmentReadiness({
+    environment: pairedEnvironment,
+    scenario,
+    renderer,
+    enabled
+  });
+  const format = pairedEnvironment?.splat.format ?? splat?.format ?? readiness.format ?? "spz";
+  return {
+    scenarioId: scenario?.id ?? pairedEnvironment?.id ?? "visual-scenario",
+    scenarioLabel: scenario?.label ?? pairedEnvironment?.label ?? "Visual scenario",
+    variantId,
+    seed: scenario?.seed ?? 0,
+    lighting: scenario?.lighting ?? "studio",
+    environment: scenario?.environment,
+    camera: {
+      jitter: scenario?.camera?.jitter ?? 0,
+      exposure: scenario?.camera?.exposure ?? 1,
+      noise: scenario?.camera?.noise ?? 0,
+      blur: scenario?.camera?.blur ?? 0
+    },
+    materials: {
+      randomizeObjectColors: Boolean(
+        scenario?.materials?.randomizeObjectColors
+      ),
+      randomizeTableMaterial: Boolean(
+        scenario?.materials?.randomizeTableMaterial
+      ),
+      roughness: scenario?.materials?.roughness,
+      metalness: scenario?.materials?.metalness
+    },
+    splatEnabled: Boolean(splat?.enabled || pairedEnvironment),
+    splatSrc: pairedEnvironment?.splat.src ?? splat?.src,
+    splatFormat: format,
+    splatRenderer: renderer ?? pairedEnvironment?.splat.renderer,
+    collisionProxyXmlPath: collisionProxy?.xmlPath,
+    collisionProxyStatus: collisionProxy?.status,
+    collisionProxyPrimitives: collisionProxy?.primitives ?? [],
+    readiness,
+    transformSource: "visualScenario.camera"
+  };
+}
 function VisualScenarioEffects(props) {
   useVisualScenarioEffects(props);
   return null;
@@ -205,25 +355,161 @@ function useSplatEnvironment({
   const resolvedSrc = src ?? scenarioEnvironment?.splat.src ?? scenario?.splat?.src;
   const resolvedFormat = format ?? scenarioEnvironment?.splat.format ?? scenario?.splat?.format ?? "spz";
   const resolvedCollisionProxy = collisionProxy ?? scenarioEnvironment?.collisionProxy ?? scenario?.splat?.collisionProxy ?? void 0;
+  const readiness = useMemo(
+    () => getSplatEnvironmentReadiness({
+      environment: scenarioEnvironment,
+      scenario,
+      renderer,
+      src: resolvedSrc,
+      format: resolvedFormat,
+      collisionProxy: resolvedCollisionProxy
+    }),
+    [
+      collisionProxy,
+      renderer,
+      resolvedCollisionProxy,
+      resolvedFormat,
+      resolvedSrc,
+      scenario,
+      scenarioEnvironment
+    ]
+  );
   return useMemo(
     () => ({
       src: resolvedSrc,
       format: resolvedFormat,
       collisionProxy: resolvedCollisionProxy,
+      readiness,
       userData: createSplatEnvironmentUserData({
         environment: scenarioEnvironment,
         src: resolvedSrc,
         format: resolvedFormat,
-        collisionProxy: resolvedCollisionProxy
+        collisionProxy: resolvedCollisionProxy,
+        readiness
       })
     }),
-    [scenarioEnvironment, resolvedSrc, resolvedFormat, resolvedCollisionProxy]
+    [
+      scenarioEnvironment,
+      resolvedSrc,
+      resolvedFormat,
+      resolvedCollisionProxy,
+      readiness
+    ]
   );
 }
+function useSplatSceneConfig({
+  sceneConfig,
+  scenario,
+  environment,
+  enabled = true,
+  renderer
+}) {
+  return useMemo(
+    () => createSplatSceneConfig({
+      sceneConfig,
+      scenario,
+      environment,
+      enabled,
+      renderer
+    }),
+    [enabled, environment, renderer, scenario, sceneConfig]
+  );
+}
+function createSplatSceneConfig({
+  sceneConfig,
+  scenario,
+  environment,
+  enabled = true,
+  renderer
+}) {
+  const resolvedEnvironment = enabled ? environment ?? (scenario ? createPairedSplatEnvironment(scenario, { renderer }) : void 0) : void 0;
+  const readiness = getSplatEnvironmentReadiness({
+    environment: resolvedEnvironment,
+    scenario,
+    renderer,
+    enabled
+  });
+  const resolvedSceneConfig = resolvedEnvironment ? withSplatEnvironment(sceneConfig, resolvedEnvironment, { renderer }) : sceneConfig;
+  return {
+    environment: resolvedEnvironment,
+    sceneConfig: resolvedSceneConfig,
+    enabled: enabled && readiness.status !== SplatEnvironmentReadinessStatus.Disabled,
+    readiness
+  };
+}
+function getSplatEnvironmentReadiness({
+  environment,
+  scenario,
+  renderer,
+  src,
+  format,
+  collisionProxy,
+  enabled = true
+}) {
+  const splat = scenario?.splat;
+  const resolvedSrc = src ?? environment?.splat.src ?? splat?.src;
+  const resolvedFormat = format ?? environment?.splat.format ?? splat?.format ?? "spz";
+  const resolvedRenderer = renderer ?? environment?.splat.renderer;
+  const resolvedCollisionProxy = collisionProxy ?? environment?.collisionProxy ?? splat?.collisionProxy ?? void 0;
+  const requiresCollisionProxy = splat?.requiresCollisionProxy ?? true;
+  if (!enabled || splat && splat.enabled === false && !environment) {
+    return {
+      status: SplatEnvironmentReadinessStatus.Disabled,
+      ready: false,
+      requiresCollisionProxy,
+      missing: [],
+      format: resolvedFormat,
+      renderer: resolvedRenderer,
+      message: "Splat environment is disabled."
+    };
+  }
+  if (!resolvedSrc) {
+    return {
+      status: SplatEnvironmentReadinessStatus.MissingSplat,
+      ready: false,
+      requiresCollisionProxy,
+      missing: ["splat"],
+      format: resolvedFormat,
+      renderer: resolvedRenderer,
+      message: "Splat environment is missing a visual asset source."
+    };
+  }
+  if (resolvedRenderer === "spark" && resolvedFormat !== "spz") {
+    return {
+      status: SplatEnvironmentReadinessStatus.UnsupportedFormat,
+      ready: false,
+      requiresCollisionProxy,
+      missing: [],
+      format: resolvedFormat,
+      renderer: resolvedRenderer,
+      message: `Spark splat rendering requires .spz assets; received ${resolvedFormat}.`
+    };
+  }
+  if (requiresCollisionProxy && !resolvedCollisionProxy?.xmlPath) {
+    return {
+      status: SplatEnvironmentReadinessStatus.MissingCollisionProxy,
+      ready: false,
+      requiresCollisionProxy,
+      missing: ["collisionProxy"],
+      format: resolvedFormat,
+      renderer: resolvedRenderer,
+      message: "Splat environment is missing paired MJCF collision proxy XML."
+    };
+  }
+  return {
+    status: SplatEnvironmentReadinessStatus.Ready,
+    ready: true,
+    requiresCollisionProxy,
+    missing: [],
+    format: resolvedFormat,
+    renderer: resolvedRenderer,
+    message: requiresCollisionProxy ? "Splat environment has visual asset and collision proxy metadata." : "Splat environment has a visual asset and does not require collision proxy metadata."
+  };
+}
 function createPairedSplatEnvironment(scenario, options = {}) {
   const splat = scenario.splat;
   const collisionProxy = splat?.collisionProxy;
-  if (!splat?.enabled || !splat.src || !collisionProxy?.xmlPath) {
+  if (!splat?.enabled || !splat.src) {
     return void 0;
   }
   return {
@@ -235,14 +521,14 @@ function createPairedSplatEnvironment(scenario, options = {}) {
       format: splat.format ?? "spz",
       renderer: options.renderer
     },
-    collisionProxy: {
+    collisionProxy: collisionProxy?.xmlPath ? {
       ...collisionProxy,
       xmlPath: collisionProxy.xmlPath
-    }
+    } : void 0
   };
 }
 function isPairedSplatEnvironment(input) {
-  return !!input && "collisionProxy" in input && "splat" in input;
+  return !!input && "splat" in input && !!input.splat && !("enabled" in input.splat);
 }
 function sceneRelativePath(sceneConfig, path) {
   const src = sceneConfig.src;
@@ -263,7 +549,7 @@ function uniquePaths(paths) {
 }
 function withSplatEnvironment(sceneConfig, input, options = {}) {
   const environment = isPairedSplatEnvironment(input) ? input : input ? createPairedSplatEnvironment(input, options) : void 0;
-  const xmlPath = environment?.collisionProxy.xmlPath;
+  const xmlPath = environment?.collisionProxy?.xmlPath;
   if (!xmlPath) return sceneConfig;
   return {
     ...sceneConfig,
@@ -277,7 +563,8 @@ function createSplatEnvironmentUserData({
   environment,
   src,
   format = "spz",
-  collisionProxy
+  collisionProxy,
+  readiness
 }) {
   return {
     role: "splat-environment",
@@ -288,7 +575,9 @@ function createSplatEnvironmentUserData({
     splatRenderer: environment?.splat.renderer,
     collisionProxyStatus: collisionProxy?.status ?? "missing",
     collisionProxyXmlPath: collisionProxy?.xmlPath,
-    collisionProxyPrimitives: collisionProxy?.primitives ?? []
+    collisionProxyPrimitives: collisionProxy?.primitives ?? [],
+    readinessStatus: readiness?.status,
+    readinessMessage: readiness?.message
   };
 }
 function createSparkSplatViewerUrl({
@@ -395,6 +684,6 @@ function clamp01(value) {
  * SPDX-License-Identifier: Apache-2.0
  */
 
-export { ScenarioLighting, SplatEnvironment, VisualScenarioEffects, createPairedSplatEnvironment, createSparkSplatViewerUrl, createSplatEnvironmentUserData, getScenarioBackground, getScenarioCameraPosition, useSplatEnvironment, useVisualScenarioEffects, withSplatEnvironment };
-//# sourceMappingURL=chunk-33CV6HSV.js.map
-//# sourceMappingURL=chunk-33CV6HSV.js.map
+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, withContacts, withSplatEnvironment };
+//# sourceMappingURL=chunk-VDSEPZYQ.js.map
+//# sourceMappingURL=chunk-VDSEPZYQ.js.map