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/src/core/SceneLoader.ts CHANGED Viewed

@@ -477,8 +477,9 @@ function sceneObjectToXml(obj: SceneObject): string {
   const solref = obj.solref ? ` solref="${obj.solref}"` : '';
   const solimp = obj.solimp ? ` solimp="${obj.solimp}"` : '';
   const condim = obj.condim ? ` condim="${obj.condim}"` : '';
+  const group = obj.group !== undefined ? ` group="${obj.group}"` : '';
   // Always set contype/conaffinity=1 so objects collide regardless of model defaults
-  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>`;
+  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>`;
 }
 /** Create virtual directory structure for a file path. */
@@ -527,6 +528,22 @@ function localFilePath(file: LocalMujocoFile): string {
   return normalizeVfsPath(file.webkitRelativePath || file.name);
 }
+function dirname(path: string): string {
+  const normalized = normalizeVfsPath(path);
+  const idx = normalized.lastIndexOf('/');
+  return idx === -1 ? '' : normalized.slice(0, idx + 1);
+}
+function relativeVfsPath(fromDir: string, targetPath: string): string {
+  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: readonly LocalMujocoFile[], options?: LoadFromFilesOptions): string {
   if (options?.sceneFile) return normalizeVfsPath(options.sceneFile);
@@ -551,6 +568,7 @@ export function createSceneConfigFromFiles(
     src: '',
     sceneFile: inferSceneFile(fileArray, options),
     files: fileArray,
+    environmentFiles: options.environmentFiles?.map(normalizeVfsPath),
     homeJoints: options.homeJoints,
     xmlPatches: options.xmlPatches,
     sceneObjects: options.sceneObjects,
@@ -558,6 +576,137 @@ export function createSceneConfigFromFiles(
   };
 }
+const ENVIRONMENT_MERGE_SECTIONS = [
+  'asset',
+  'worldbody',
+  'contact',
+  'equality',
+  'tendon',
+  'sensor',
+  'keyframe',
+  'custom',
+  'extension',
+] as const;
+function directChild(parent: Element, tagName: string): Element | null {
+  const lower = tagName.toLowerCase();
+  for (const child of Array.from(parent.children)) {
+    if (child.tagName.toLowerCase() === lower) return child;
+  }
+  return null;
+}
+function ensureTopLevelSection(doc: XMLDocument, tagName: string): Element {
+  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: XMLDocument) {
+  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: string): boolean {
+  return /^[a-z]+:\/\//i.test(path) || path.startsWith('package://') || path.startsWith('/');
+}
+function fileReferencePrefix(el: Element, compilerDirs: ReturnType<typeof readCompilerDirs>): string {
+  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: Element, sourceFile: string, targetFile: string, sourceDoc: XMLDocument) {
+  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: XMLDocument): boolean {
+  return doc.getElementsByTagName('parsererror').length > 0;
+}
+function composeEnvironmentXml(
+  sceneXml: string,
+  config: SceneConfig,
+  parser: DOMParser,
+  environmentXmlByPath: Map<string, string>
+): string {
+  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) as Element;
+        rewriteFileReferencesForMerge(imported, environmentFile, config.sceneFile, environmentDoc);
+        targetSection.appendChild(imported);
+      }
+    }
+  }
+  return new XMLSerializer().serializeToString(sceneDoc);
+}
+function findTextByConfiguredPath(textByPath: Map<string, string>, configuredPath: string): string | undefined {
+  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 undefined;
+}
 function applyXmlPatches(text: string, fname: string, config: SceneConfig): string {
   let result = text;
   for (const patch of config.xmlPatches ?? []) {
@@ -627,10 +776,25 @@ async function loadSceneFromFiles(
     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 = new Map<string, string>();
+  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);
   }
@@ -689,6 +853,18 @@ export async function loadScene(
   const baseUrl = config.src.endsWith('/') ? config.src : config.src + '/';
+  const environmentXmlByPath = new Map<string, string>();
+  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 = new Set<string>();
   const xmlQueue: string[] = [config.sceneFile];
   const assetFiles: string[] = [];
@@ -714,7 +890,10 @@ export async function loadScene(
       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);

package/src/hooks/useFrameCapture.ts ADDED Viewed

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * useFrameCapture — still-frame capture for canvas-backed MuJoCo/R3F scenes.
+ */
+import { useCallback, useState } from 'react';
+import type React from 'react';
+export type FrameCaptureStatus = 'idle' | 'capturing' | 'captured' | 'error';
+export type FrameCaptureTarget =
+  | HTMLCanvasElement
+  | HTMLElement
+  | null
+  | undefined;
+export type FrameCaptureTargetRef =
+  React.RefObject<HTMLCanvasElement | HTMLElement | null>;
+export interface FrameCaptureOptions {
+  target?: FrameCaptureTarget | FrameCaptureTargetRef;
+  type?: string;
+  quality?: number;
+  waitForAnimationFrame?: boolean;
+}
+export interface FrameCaptureResult {
+  canvas: HTMLCanvasElement;
+  dataUrl: string;
+  type: string;
+}
+export interface FrameCaptureBlobResult {
+  canvas: HTMLCanvasElement;
+  blob: Blob;
+  type: string;
+}
+export interface FrameCaptureAPI {
+  status: FrameCaptureStatus;
+  error: Error | null;
+  isCapturing: boolean;
+  capture: (options?: FrameCaptureOptions) => Promise<FrameCaptureResult>;
+  captureBlob: (
+    options?: FrameCaptureOptions
+  ) => Promise<FrameCaptureBlobResult>;
+  reset: () => void;
+}
+function isTargetRef(
+  target: FrameCaptureOptions['target']
+): target is FrameCaptureTargetRef {
+  return Boolean(target && typeof target === 'object' && 'current' in target);
+}
+function resolveCanvasTarget(
+  target: FrameCaptureOptions['target']
+): HTMLCanvasElement {
+  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<void>((resolve) => {
+    requestAnimationFrame(() => resolve());
+  });
+}
+/**
+ * Capture the current canvas frame as a data URL.
+ *
+ * For WebGL scenes, create the renderer with `preserveDrawingBuffer: true`
+ * when you need deterministic captures after the frame has presented.
+ */
+export async function captureFrame(
+  options: FrameCaptureOptions
+): Promise<FrameCaptureResult> {
+  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,
+  };
+}
+/**
+ * Capture the current canvas frame as a Blob.
+ */
+export async function captureFrameBlob(
+  options: FrameCaptureOptions
+): Promise<FrameCaptureBlobResult> {
+  const type = options.type ?? 'image/png';
+  const canvas = resolveCanvasTarget(options.target);
+  if (options.waitForAnimationFrame ?? true) {
+    await waitForNextAnimationFrame();
+  }
+  const blob = await new Promise<Blob>((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 };
+}
+/**
+ * React state wrapper around `captureFrame` and `captureFrameBlob`.
+ */
+export function useFrameCapture(
+  defaultOptions: FrameCaptureOptions = {}
+): FrameCaptureAPI {
+  const [status, setStatus] = useState<FrameCaptureStatus>('idle');
+  const [error, setError] = useState<Error | null>(null);
+  const reset = useCallback(() => {
+    setStatus('idle');
+    setError(null);
+  }, []);
+  const capture = useCallback(
+    async (options: FrameCaptureOptions = {}) => {
+      setStatus('capturing');
+      setError(null);
+      try {
+        const result = await captureFrame({ ...defaultOptions, ...options });
+        setStatus('captured');
+        return result;
+      } catch (nextError) {
+        const error =
+          nextError instanceof Error
+            ? nextError
+            : new Error('Unable to capture the current canvas frame.');
+        setError(error);
+        setStatus('error');
+        throw error;
+      }
+    },
+    [defaultOptions]
+  );
+  const captureBlob = useCallback(
+    async (options: FrameCaptureOptions = {}) => {
+      setStatus('capturing');
+      setError(null);
+      try {
+        const result = await captureFrameBlob({
+          ...defaultOptions,
+          ...options,
+        });
+        setStatus('captured');
+        return result;
+      } catch (nextError) {
+        const error =
+          nextError instanceof Error
+            ? nextError
+            : new Error('Unable to capture the current canvas frame.');
+        setError(error);
+        setStatus('error');
+        throw error;
+      }
+    },
+    [defaultOptions]
+  );
+  return {
+    status,
+    error,
+    isCapturing: status === 'capturing',
+    capture,
+    captureBlob,
+    reset,
+  };
+}

package/src/hooks/usePolicy.ts CHANGED Viewed

@@ -6,7 +6,7 @@
  */
 import { useRef } from 'react';
-import { useMujocoContext, useBeforePhysicsStep } from '../core/MujocoSimProvider';
+import { useBeforePhysicsStep } from '../core/MujocoSimProvider';
 import type { PolicyConfig } from '../types';
 /**
@@ -20,12 +20,13 @@ import type { PolicyConfig } from '../types';
  * @returns { step, isRunning } control handles
  */
 export function usePolicy(config: PolicyConfig) {
-  const { mjModelRef } = useMujocoContext();
   const lastActionTimeRef = useRef(0);
+  const lastObservationRef = useRef<ReturnType<PolicyConfig['onObservation']> | null>(null);
   const lastActionRef = useRef<Float32Array | Float64Array | number[] | null>(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;
@@ -37,13 +38,15 @@ export function usePolicy(config: PolicyConfig) {
     // Check if it's time for a new action
     if (data.time - lastActionTimeRef.current >= interval) {
       // Build observation
-      const obs = cfg.onObservation(model, data);
+      const observation = cfg.onObservation({ model, data });
+      const action = cfg.infer ? cfg.infer({ observation, model, data }) : observation;
-      // Apply action (consumer does inference inline or uses cached result)
-      cfg.onAction(obs, model, data);
+      // Apply action. If `infer` is omitted, this preserves the legacy inline-controller path.
+      cfg.onAction({ action, observation, model, data });
       lastActionTimeRef.current = data.time;
-      lastActionRef.current = obs;
+      lastObservationRef.current = observation;
+      lastActionRef.current = action;
     }
   });
@@ -51,6 +54,7 @@ export function usePolicy(config: PolicyConfig) {
     get isRunning() { return isRunningRef.current; },
     start: () => { isRunningRef.current = true; },
     stop: () => { isRunningRef.current = false; },
-    get lastObservation() { return lastActionRef.current; },
+    get lastObservation() { return lastObservationRef.current; },
+    get lastAction() { return lastActionRef.current; },
   };
 }

package/src/hooks/useSceneLights.ts CHANGED Viewed

@@ -34,28 +34,41 @@ export function useSceneLights(intensity = 1.0) {
     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 castShadow = lightCastShadow ? lightCastShadow[i] !== 0 : false;
-      const mjIntensity = model.light_intensity ? model.light_intensity[i] : 1.0;
+      const mjIntensity = lightIntensity ? lightIntensity[i] : 1.0;
       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 THREE.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 THREE.DirectionalLight(color, finalIntensity);
@@ -78,17 +91,17 @@ export function useSceneLights(intensity = 1.0) {
         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 THREE.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;
         }
@@ -115,3 +128,21 @@ export function useSceneLights(intensity = 1.0) {
     };
   }, [status, mjModelRef, scene, intensity]);
 }
+function getModelArray(model: unknown, key: string): ArrayLike<number> | undefined {
+  try {
+    const value = (model as Record<string, unknown>)[key];
+    return isArrayLikeNumber(value) ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+function isArrayLikeNumber(value: unknown): value is ArrayLike<number> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'length' in value &&
+    typeof (value as ArrayLike<number>).length === 'number'
+  );
+}

package/src/index.ts CHANGED Viewed

@@ -41,6 +41,19 @@ export { IkGizmo } from './components/IkGizmo';
 export { ContactMarkers } from './components/ContactMarkers';
 export { DragInteraction } from './components/DragInteraction';
 export { SceneLights } from './components/SceneLights';
+export {
+  ScenarioLighting,
+  SplatEnvironment,
+  VisualScenarioEffects,
+  createPairedSplatEnvironment,
+  createSparkSplatViewerUrl,
+  createSplatEnvironmentUserData,
+  getScenarioBackground,
+  getScenarioCameraPosition,
+  useSplatEnvironment,
+  useVisualScenarioEffects,
+  withSplatEnvironment,
+} from './components/VisualScenario';
 export { Debug } from './components/Debug';
 export { TendonRenderer } from './components/TendonRenderer';
 export { FlexRenderer } from './components/FlexRenderer';
@@ -64,6 +77,20 @@ export { useTrajectoryPlayer } from './hooks/useTrajectoryPlayer';
 export { useTrajectoryRecorder } from './hooks/useTrajectoryRecorder';
 export { useGamepad } from './hooks/useGamepad';
 export { useVideoRecorder } from './hooks/useVideoRecorder';
+export {
+  captureFrame,
+  captureFrameBlob,
+  useFrameCapture,
+} from './hooks/useFrameCapture';
+export type {
+  FrameCaptureAPI,
+  FrameCaptureBlobResult,
+  FrameCaptureOptions,
+  FrameCaptureResult,
+  FrameCaptureStatus,
+  FrameCaptureTarget,
+  FrameCaptureTargetRef,
+} from './hooks/useFrameCapture';
 export { useCtrlNoise } from './hooks/useCtrlNoise';
 export { useBodyMeshes } from './hooks/useBodyMeshes';
 export { useSelectionHighlight } from './hooks/useSelectionHighlight';
@@ -115,6 +142,10 @@ export type {
   KeyboardTeleopConfig,
   // Policy
   PolicyConfig,
+  PolicyVector,
+  PolicyObservationInput,
+  PolicyInferenceInput,
+  PolicyActionInput,
   // Observations
   ObservationConfig,
   ObservationHandle,
@@ -127,6 +158,23 @@ export type {
   DragInteractionProps,
   DebugProps,
   SceneLightsProps,
+  ScenarioLightingPreset,
+  SplatFormat,
+  SplatRendererKind,
+  SplatCollisionPrimitive,
+  ScenarioCameraConfig,
+  SplatAssetConfig,
+  SplatScenarioConfig,
+  SplatCollisionProxyConfig,
+  PairedSplatEnvironmentConfig,
+  SplatEnvironmentMetadataInput,
+  SplatEnvironmentMetadata,
+  SplatSceneInput,
+  VisualScenarioConfig,
+  ScenarioLightingProps,
+  ScenarioMaterialConfig,
+  SplatEnvironmentProps,
+  VisualScenarioEffectsProps,
   TrajectoryPlayerProps,
   ContactListenerProps,
   // API