mujoco-react 8.5.0 → 8.7.0

package/src/core/MujocoSimProvider.tsx

@@ -25,6 +25,8 @@ import {
   ContactInfo,
   GeomInfo,
   JointInfo,
+  LoadFromFilesOptions,
+  LocalMujocoFile,
   ModelOptions,
   MujocoSimAPI,
   PhysicsStepCallback,
@@ -34,9 +36,11 @@ import {
   SensorInfo,
   SiteInfo,
   StateSnapshot,
+  XmlPatch,
 } from '../types';
 import {
   loadScene,
+  createSceneConfigFromFiles,
   findKeyframeByName,
   findBodyByName,
   findGeomByName,
@@ -110,6 +114,8 @@ export interface MujocoSimContextValue {
   pausedRef: React.RefObject<boolean>;
   speedRef: React.RefObject<number>;
   substepsRef: React.RefObject<number>;
+  interpolateRef: React.RefObject<boolean>;
+  interpolationStateRef: React.RefObject<BodyInterpolationState>;
   onSelectionRef: React.RefObject<
     ((bodyId: number, name: string) => void) | undefined
   >;
@@ -123,6 +129,15 @@ export interface MujocoSimContextValue {
   status: 'loading' | 'ready' | 'error';
 }
 
+export interface BodyInterpolationState {
+  alpha: number;
+  previousXpos: Float64Array;
+  previousXquat: Float64Array;
+  currentXpos: Float64Array;
+  currentXquat: Float64Array;
+  valid: boolean;
+}
+
 const MujocoSimContext = createContext<MujocoSimContextValue | null>(null);
 
 export type UseMujocoResult =
@@ -214,6 +229,7 @@ interface MujocoSimProviderProps {
   substeps?: number;
   paused?: boolean;
   speed?: number;
+  interpolate?: boolean;
   children: React.ReactNode;
 }
 
@@ -230,6 +246,7 @@ export function MujocoSimProvider({
   substeps,
   paused,
   speed,
+  interpolate,
   children,
 }: MujocoSimProviderProps) {
   const { gl, camera } = useThree();
@@ -243,6 +260,16 @@ export function MujocoSimProvider({
   const pausedRef = useRef(paused ?? false);
   const speedRef = useRef(speed ?? 1);
   const substepsRef = useRef(substeps ?? 1);
+  const interpolateRef = useRef(interpolate ?? false);
+  const interpolationStateRef = useRef<BodyInterpolationState>({
+    alpha: 1,
+    previousXpos: new Float64Array(0),
+    previousXquat: new Float64Array(0),
+    currentXpos: new Float64Array(0),
+    currentXquat: new Float64Array(0),
+    valid: false,
+  });
+  const physicsAccumulatorRef = useRef(0);
   const stepsToRunRef = useRef(0);
   const loadGenRef = useRef(0);
 
@@ -259,12 +286,13 @@ export function MujocoSimProvider({
   const hiddenBodiesRef = useRef(new Set<string>());
   const bodyReloadTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  configRef.current = config;
+  useEffect(() => { configRef.current = config; }, [config]);
 
   // Sync declarative props to refs
   useEffect(() => { pausedRef.current = paused ?? false; }, [paused]);
   useEffect(() => { speedRef.current = speed ?? 1; }, [speed]);
   useEffect(() => { substepsRef.current = substeps ?? 1; }, [substeps]);
+  useEffect(() => { interpolateRef.current = interpolate ?? false; }, [interpolate]);
 
   // Sync gravity prop
   useEffect(() => {
@@ -312,6 +340,8 @@ export function MujocoSimProvider({
 
         mjModelRef.current = result.mjModel;
         mjDataRef.current = result.mjData;
+        physicsAccumulatorRef.current = 0;
+        interpolationStateRef.current.valid = false;
 
         // Apply declarative physics props after load
         if (gravity && result.mjModel.opt?.gravity) {
@@ -340,6 +370,8 @@ export function MujocoSimProvider({
       mjDataRef.current?.delete();
       mjModelRef.current = null;
       mjDataRef.current = null;
+      physicsAccumulatorRef.current = 0;
+      interpolationStateRef.current.valid = false;
       try { mujoco.FS.unmount('/working'); } catch { /* ignore */ }
     };
   }, [mujoco, config]);
@@ -380,21 +412,62 @@ export function MujocoSimProvider({
       cb(model, data);
     }
 
-    // Step physics with substeps
     const numSubsteps = substepsRef.current;
-    if (stepsToRunRef.current > 0) {
+    if (!interpolateRef.current) {
+      // Step physics with substeps
+      if (stepsToRunRef.current > 0) {
+        for (let s = 0; s < stepsToRunRef.current; s++) {
+          mujoco.mj_step(model, data);
+        }
+        stepsToRunRef.current = 0;
+      } else {
+        const startSimTime = data.time;
+        const clampedDelta = Math.min(delta, 1 / 15); // cap to avoid spiral of death
+        const frameTime = clampedDelta * speedRef.current;
+        while (data.time - startSimTime < frameTime) {
+          for (let s = 0; s < numSubsteps; s++) {
+            mujoco.mj_step(model, data);
+          }
+        }
+      }
+    } else if (stepsToRunRef.current > 0) {
+      ensureInterpolationBuffers(model);
+      copyBodyPose(data, interpolationStateRef.current.previousXpos, interpolationStateRef.current.previousXquat);
       for (let s = 0; s < stepsToRunRef.current; s++) {
         mujoco.mj_step(model, data);
       }
+      copyBodyPose(data, interpolationStateRef.current.currentXpos, interpolationStateRef.current.currentXquat);
+      interpolationStateRef.current.alpha = 1;
+      interpolationStateRef.current.valid = true;
       stepsToRunRef.current = 0;
     } else {
-      const startSimTime = data.time;
+      ensureInterpolationBuffers(model);
       const clampedDelta = Math.min(delta, 1 / 15); // cap to avoid spiral of death
-      const frameTime = clampedDelta * speedRef.current;
-      while (data.time - startSimTime < frameTime) {
+      physicsAccumulatorRef.current += clampedDelta * speedRef.current;
+      const stepDt = Math.max((model.opt?.timestep ?? 0.002) * Math.max(1, numSubsteps), 1e-6);
+      let stepped = false;
+
+      while (physicsAccumulatorRef.current >= stepDt) {
+        copyBodyPose(data, interpolationStateRef.current.previousXpos, interpolationStateRef.current.previousXquat);
         for (let s = 0; s < numSubsteps; s++) {
           mujoco.mj_step(model, data);
         }
+        copyBodyPose(data, interpolationStateRef.current.currentXpos, interpolationStateRef.current.currentXquat);
+        physicsAccumulatorRef.current -= stepDt;
+        stepped = true;
+      }
+
+      if (!interpolationStateRef.current.valid) {
+        copyBodyPose(data, interpolationStateRef.current.previousXpos, interpolationStateRef.current.previousXquat);
+        copyBodyPose(data, interpolationStateRef.current.currentXpos, interpolationStateRef.current.currentXquat);
+      }
+
+      interpolationStateRef.current.alpha = Math.min(Math.max(physicsAccumulatorRef.current / stepDt, 0), 1);
+      interpolationStateRef.current.valid = true;
+
+      if (!stepped) {
+        onStepRef.current?.(data.time);
+        return;
       }
     }
 
@@ -406,6 +479,21 @@ export function MujocoSimProvider({
     onStepRef.current?.(data.time);
   }, -1);
 
+  function ensureInterpolationBuffers(model: MujocoModel) {
+    const state = interpolationStateRef.current;
+    const xposLength = model.nbody * 3;
+    const xquatLength = model.nbody * 4;
+    if (state.previousXpos.length !== xposLength) state.previousXpos = new Float64Array(xposLength);
+    if (state.currentXpos.length !== xposLength) state.currentXpos = new Float64Array(xposLength);
+    if (state.previousXquat.length !== xquatLength) state.previousXquat = new Float64Array(xquatLength);
+    if (state.currentXquat.length !== xquatLength) state.currentXquat = new Float64Array(xquatLength);
+  }
+
+  function copyBodyPose(data: MujocoData, xpos: Float64Array, xquat: Float64Array) {
+    xpos.set(data.xpos.subarray(0, xpos.length));
+    xquat.set(data.xquat.subarray(0, xquat.length));
+  }
+
   // --- API Methods ---
 
   const reset = useCallback(() => {
@@ -849,7 +937,7 @@ export function MujocoSimProvider({
       mjDataRef.current = null;
       setStatus('loading');
 
-      const result = await loadScene(mujoco, newConfig);
+      const result = await loadScene(mujoco, buildMergedConfig(newConfig));
 
       if (gen !== loadGenRef.current) {
         result.mjModel.delete();
@@ -859,6 +947,8 @@ export function MujocoSimProvider({
 
       mjModelRef.current = result.mjModel;
       mjDataRef.current = result.mjData;
+      physicsAccumulatorRef.current = 0;
+      interpolationStateRef.current.valid = false;
       configRef.current = newConfig;
 
       setStatus('ready');
@@ -874,10 +964,41 @@ export function MujocoSimProvider({
     if (bodyReloadTimerRef.current) clearTimeout(bodyReloadTimerRef.current);
     bodyReloadTimerRef.current = setTimeout(() => {
       bodyReloadTimerRef.current = null;
-      loadSceneApi(buildMergedConfig(configRef.current));
+      loadSceneApi(configRef.current);
     }, 0);
   }, [loadSceneApi]);
 
+  const loadFromFilesApi = useCallback(
+    async (files: FileList | readonly LocalMujocoFile[], options?: LoadFromFilesOptions): Promise<void> => {
+      await loadSceneApi(createSceneConfigFromFiles(files, options));
+    },
+    [loadSceneApi]
+  );
+
+  const addBodyApi = useCallback(async (body: SceneObject): Promise<void> => {
+    const current = configRef.current;
+    const sceneObjects = [
+      ...(current.sceneObjects ?? []).filter((obj) => obj.name !== body.name),
+      body,
+    ];
+    await loadSceneApi({ ...current, sceneObjects });
+  }, [loadSceneApi]);
+
+  const removeBodyApi = useCallback(async (name: string): Promise<void> => {
+    const current = configRef.current;
+    bodyRegistryRef.current.delete(name);
+    const sceneObjects = (current.sceneObjects ?? []).filter((obj) => obj.name !== name);
+    await loadSceneApi({ ...current, sceneObjects });
+  }, [loadSceneApi]);
+
+  const recompileApi = useCallback(async (patches: XmlPatch[] = []): Promise<void> => {
+    const current = configRef.current;
+    await loadSceneApi({
+      ...current,
+      xmlPatches: patches.length ? [...(current.xmlPatches ?? []), ...patches] : current.xmlPatches,
+    });
+  }, [loadSceneApi]);
+
   const getCanvasSnapshot = useCallback(
     (width?: number, height?: number, mimeType = 'image/jpeg'): string => {
       if (width && height) {
@@ -961,7 +1082,7 @@ export function MujocoSimProvider({
   const api = useMemo<MujocoSimAPI>(
     () => ({
       get status() { return status; },
-      config,
+      get config() { return configRef.current; },
       reset,
       setSpeed,
       togglePause,
@@ -1000,6 +1121,10 @@ export function MujocoSimProvider({
       getKeyframeNames,
       getKeyframeCount,
       loadScene: loadSceneApi,
+      loadFromFiles: loadFromFilesApi,
+      addBody: addBodyApi,
+      removeBody: removeBodyApi,
+      recompile: recompileApi,
       getCanvasSnapshot,
       project2DTo3D,
       setBodyMass,
@@ -1009,7 +1134,7 @@ export function MujocoSimProvider({
       mjDataRef,
     }),
     [
-      status, config, reset, setSpeed, togglePause, setPaused, step,
+      status, reset, setSpeed, togglePause, setPaused, step,
       getTime, getTimestep, applyKeyframe, saveState, restoreState,
       setQpos, setQvel, getQpos, getQvel, setCtrl, getCtrl,
       getControlMapApi, getActuatedJointsApi, resolveControlGroupApi,
@@ -1017,6 +1142,7 @@ export function MujocoSimProvider({
       getSensorData, getContacts, getBodies, getJoints, getGeoms, getSites,
       getActuatorsApi, getSensors, getModelOption, setGravity, setTimestepApi,
       raycast, getKeyframeNames, getKeyframeCount, loadSceneApi,
+      loadFromFilesApi, addBodyApi, removeBodyApi, recompileApi,
       getCanvasSnapshot, project2DTo3D,
       setBodyMass, setGeomFriction, setGeomSize,
     ]
@@ -1034,6 +1160,8 @@ export function MujocoSimProvider({
       pausedRef,
       speedRef,
       substepsRef,
+      interpolateRef,
+      interpolationStateRef,
       onSelectionRef,
       beforeStepCallbacks,
       afterStepCallbacks,

package/src/core/SceneLoader.ts

@@ -10,6 +10,8 @@ import type {
   ControlGroupSelector,
   ControlJointInfo,
   JointInfo,
+  LoadFromFilesOptions,
+  LocalMujocoFile,
   MujocoData,
   MujocoModel,
   MujocoModule,
@@ -505,6 +507,170 @@ function loadModelFromPath(mujoco: MujocoModule, path: string): MujocoModel {
   throw new Error('MuJoCo WASM module does not expose an XML path loader');
 }
 
+function isModelTextFile(fname: string): boolean {
+  const lower = fname.toLowerCase();
+  return lower.endsWith('.xml') || lower.endsWith('.urdf') || lower.endsWith('.mjcf');
+}
+
+function normalizeVfsPath(path: string): string {
+  const parts = path.replace(/\\/g, '/').split('/');
+  const norm: string[] = [];
+  for (const part of parts) {
+    if (!part || part === '.') continue;
+    if (part === '..') norm.pop();
+    else norm.push(part);
+  }
+  return norm.join('/');
+}
+
+function localFilePath(file: LocalMujocoFile): string {
+  return normalizeVfsPath(file.webkitRelativePath || file.name);
+}
+
+function inferSceneFile(files: readonly LocalMujocoFile[], options?: LoadFromFilesOptions): string {
+  if (options?.sceneFile) return normalizeVfsPath(options.sceneFile);
+
+  const paths = files.map(localFilePath);
+  const preferred = ['scene.xml', 'model.xml', 'robot.xml', 'scene.urdf', 'model.urdf', 'robot.urdf'];
+  for (const name of preferred) {
+    const match = paths.find((path) => path.endsWith(name));
+    if (match) return match;
+  }
+
+  const firstModel = paths.find(isModelTextFile);
+  if (!firstModel) throw new Error('No MJCF XML or URDF file found in FileList');
+  return firstModel;
+}
+
+export function createSceneConfigFromFiles(
+  files: FileList | readonly LocalMujocoFile[],
+  options: LoadFromFilesOptions = {}
+): SceneConfig {
+  const fileArray = Array.from(files) as LocalMujocoFile[];
+  return {
+    src: '',
+    sceneFile: inferSceneFile(fileArray, options),
+    files: fileArray,
+    homeJoints: options.homeJoints,
+    xmlPatches: options.xmlPatches,
+    sceneObjects: options.sceneObjects,
+    onReset: options.onReset,
+  };
+}
+
+function applyXmlPatches(text: string, fname: string, config: SceneConfig): string {
+  let result = text;
+  for (const patch of config.xmlPatches ?? []) {
+    if (fname.endsWith(patch.target) || fname === patch.target) {
+      if (patch.replace) {
+        const [from, to] = patch.replace;
+        if (result.includes(from)) {
+          result = result.replace(from, to);
+        } else {
+          const preview = from.length > 80 ? `${from.slice(0, 80)}...` : from;
+          console.warn(`XML patch replace pattern not found in ${fname}: "${preview}"`);
+        }
+      }
+      if (patch.inject && patch.injectAfter) {
+        const idx = result.indexOf(patch.injectAfter);
+        if (idx !== -1) {
+          const tagEnd = result.indexOf('>', idx + patch.injectAfter.length);
+          if (tagEnd !== -1) {
+            result = result.slice(0, tagEnd + 1) + patch.inject + result.slice(tagEnd + 1);
+          } else {
+            console.warn(`XML patch inject failed in ${fname}: could not find tag end after "${patch.injectAfter}"`);
+          }
+        } else {
+          const preview = patch.injectAfter.length > 80
+            ? `${patch.injectAfter.slice(0, 80)}...`
+            : patch.injectAfter;
+          console.warn(`XML patch inject anchor not found in ${fname}: "${preview}"`);
+        }
+      }
+    }
+  }
+
+  if (fname === config.sceneFile && config.sceneObjects?.length && result.includes('</worldbody>')) {
+    const xml = config.sceneObjects.map((obj) => sceneObjectToXml(obj)).join('');
+    result = result.replace('</worldbody>', xml + '</worldbody>');
+  }
+
+  return result;
+}
+
+async function loadSceneFromFiles(
+  mujoco: MujocoModule,
+  config: SceneConfig,
+  onProgress?: (msg: string) => void
+): Promise<LoadResult> {
+  const files = config.files ?? [];
+  if (!files.length) throw new Error('loadFromFiles requires at least one File');
+
+  try { mujoco.FS.unmount('/working'); } catch { /* ignore */ }
+  try { mujoco.FS.mkdir('/working'); } catch { /* ignore */ }
+
+  const parser = new DOMParser();
+  const byPath = new Map<string, LocalMujocoFile>();
+  const byBasename = new Map<string, LocalMujocoFile>();
+  const written = new Set<string>();
+  const textByPath = new Map<string, string>();
+
+  for (const file of files) {
+    const path = localFilePath(file);
+    byPath.set(path, file);
+    byBasename.set(path.split('/').pop() ?? path, file);
+  }
+
+  for (const [path, file] of byPath) {
+    onProgress?.(`Reading ${path}...`);
+    ensureDir(mujoco, path);
+    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);
+  }
+
+  for (const [path, text] of textByPath) {
+    const deps = collectDependencyPaths(text, path, parser);
+    for (const dep of deps) {
+      if (written.has(dep)) continue;
+      const file = byPath.get(dep) ?? byBasename.get(dep.split('/').pop() ?? dep);
+      if (!file) continue;
+      ensureDir(mujoco, dep);
+      if (isModelTextFile(dep)) {
+        mujoco.FS.writeFile(`/working/${dep}`, applyXmlPatches(await file.text(), dep, config));
+      } else {
+        mujoco.FS.writeFile(`/working/${dep}`, new Uint8Array(await file.arrayBuffer()));
+      }
+      written.add(dep);
+    }
+  }
+
+  onProgress?.('Loading model...');
+  const mjModel = loadModelFromPath(mujoco, `/working/${config.sceneFile}`);
+  const mjData = new mujoco.MjData(mjModel);
+  applyInitialPose(mjModel, mjData, config);
+  mujoco.mj_forward(mjModel, mjData);
+
+  return { mjModel, mjData };
+}
+
+function applyInitialPose(mjModel: MujocoModel, mjData: MujocoData, config: SceneConfig) {
+  if (!config.homeJoints) return;
+  const homeCount = Math.min(config.homeJoints.length, Math.max(mjModel.nu, mjModel.nq));
+  for (let i = 0; i < homeCount; i++) {
+    if (i < mjModel.nu) mjData.ctrl[i] = config.homeJoints[i];
+    if (i < mjModel.nq) {
+      const qposAdr = i < mjModel.nu ? getActuatedScalarQposAdr(mjModel, i) : -1;
+      mjData.qpos[qposAdr !== -1 ? qposAdr : i] = config.homeJoints[i];
+    }
+  }
+}
+
 /**
  * Config-driven scene loader — replaces the old RobotLoader + patchSingleRobot approach.
  */
@@ -513,6 +679,10 @@ export async function loadScene(
   config: SceneConfig,
   onProgress?: (msg: string) => void
 ): Promise<LoadResult> {
+  if (config.files?.length) {
+    return loadSceneFromFiles(mujoco, config, onProgress);
+  }
+
   // 1. Clean up virtual filesystem
   try { mujoco.FS.unmount('/working'); } catch { /* ignore */ }
   try { mujoco.FS.mkdir('/working'); } catch { /* ignore */ }
@@ -530,7 +700,7 @@ export async function loadScene(
     if (downloaded.has(fname)) continue;
     downloaded.add(fname);
 
-    if (!fname.endsWith('.xml')) {
+    if (!isModelTextFile(fname)) {
       // Non-XML discovered during XML scan — collect for parallel download
       assetFiles.push(fname);
       continue;
@@ -544,44 +714,7 @@ export async function loadScene(
       continue;
     }
 
-    let text = await res.text();
-
-    // 3. Apply XML patches from config
-    for (const patch of config.xmlPatches ?? []) {
-      if (fname.endsWith(patch.target) || fname === patch.target) {
-        if (patch.replace) {
-          const [from, to] = patch.replace;
-          if (text.includes(from)) {
-            text = text.replace(from, to);
-          } else {
-            const preview = from.length > 80 ? `${from.slice(0, 80)}...` : from;
-            console.warn(`XML patch replace pattern not found in ${fname}: "${preview}"`);
-          }
-        }
-        if (patch.inject && patch.injectAfter) {
-          const idx = text.indexOf(patch.injectAfter);
-          if (idx !== -1) {
-            const tagEnd = text.indexOf('>', idx + patch.injectAfter.length);
-            if (tagEnd !== -1) {
-              text = text.slice(0, tagEnd + 1) + patch.inject + text.slice(tagEnd + 1);
-            } else {
-              console.warn(`XML patch inject failed in ${fname}: could not find tag end after "${patch.injectAfter}"`);
-            }
-          } else {
-            const preview = patch.injectAfter.length > 80
-              ? `${patch.injectAfter.slice(0, 80)}...`
-              : patch.injectAfter;
-            console.warn(`XML patch inject anchor not found in ${fname}: "${preview}"`);
-          }
-        }
-      }
-    }
-
-    // 4. Inject scene objects into the scene file
-    if (fname === config.sceneFile && config.sceneObjects?.length) {
-      const xml = config.sceneObjects.map((obj) => sceneObjectToXml(obj)).join('');
-      text = text.replace('</worldbody>', xml + '</worldbody>');
-    }
+    const text = applyXmlPatches(await res.text(), fname, config);
 
     ensureDir(mujoco, fname);
     mujoco.FS.writeFile(`/working/${fname}`, text);
@@ -617,16 +750,7 @@ export async function loadScene(
 
   // 6. Set initial pose — set both ctrl and qpos so robot starts at home.
   //    If homeJoints is not provided, keep raw MuJoCo defaults.
-  if (config.homeJoints) {
-    const homeCount = Math.min(config.homeJoints.length, mjModel.nu);
-    for (let i = 0; i < homeCount; i++) {
-      mjData.ctrl[i] = config.homeJoints[i];
-      const qposAdr = getActuatedScalarQposAdr(mjModel, i);
-      if (qposAdr !== -1) {
-        mjData.qpos[qposAdr] = config.homeJoints[i];
-      }
-    }
-  }
+  applyInitialPose(mjModel, mjData, config);
 
   mujoco.mj_forward(mjModel, mjData);
 
@@ -643,6 +767,16 @@ function scanDependencies(
   downloaded: Set<string>,
   queue: string[]
 ) {
+  for (const fullPath of collectDependencyPaths(xmlString, currentFile, parser)) {
+    if (!downloaded.has(fullPath)) queue.push(fullPath);
+  }
+}
+
+function collectDependencyPaths(
+  xmlString: string,
+  currentFile: string,
+  parser: DOMParser
+): string[] {
   const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
 
   const compiler = xmlDoc.querySelector('compiler');
@@ -653,9 +787,11 @@ function scanDependencies(
     ? currentFile.substring(0, currentFile.lastIndexOf('/') + 1)
     : '';
 
-  xmlDoc.querySelectorAll('[file]').forEach((el) => {
-    const fileAttr = el.getAttribute('file');
+  const paths: string[] = [];
+  xmlDoc.querySelectorAll('[file], [filename]').forEach((el) => {
+    const fileAttr = el.getAttribute('file') ?? el.getAttribute('filename');
     if (!fileAttr) return;
+    if (/^[a-z]+:\/\//i.test(fileAttr) || fileAttr.startsWith('package://')) return;
 
     let prefix = '';
     if (el.tagName.toLowerCase() === 'mesh') {
@@ -664,15 +800,9 @@ function scanDependencies(
       prefix = textureDir ? textureDir + '/' : '';
     }
 
-    let fullPath = (currentDir + prefix + fileAttr).replace(/\/\//g, '/');
-    const parts = fullPath.split('/');
-    const norm: string[] = [];
-    for (const p of parts) {
-      if (p === '..') norm.pop();
-      else if (p !== '.') norm.push(p);
-    }
-    fullPath = norm.join('/');
+    const fullPath = normalizeVfsPath(currentDir + prefix + fileAttr);
 
-    if (!downloaded.has(fullPath)) queue.push(fullPath);
+    paths.push(fullPath);
   });
+  return paths;
 }

package/src/index.ts

@@ -44,6 +44,7 @@ export { SceneLights } from './components/SceneLights';
 export { Debug } from './components/Debug';
 export { TendonRenderer } from './components/TendonRenderer';
 export { FlexRenderer } from './components/FlexRenderer';
+export { InstancedGeomRenderer } from './components/InstancedGeomRenderer';
 export { ContactListener } from './components/ContactListener';
 export { TrajectoryPlayer } from './components/TrajectoryPlayer';
 
@@ -141,6 +142,16 @@ export type {
   JointStateResult,
   // Register (type-safe named resources)
   Register,
+  RegisteredRobotMap,
+  RobotResource,
+  Robots,
+  RobotActuators,
+  RobotSensors,
+  RobotBodies,
+  RobotJoints,
+  RobotSites,
+  RobotGeoms,
+  RobotKeyframes,
   Actuators,
   Sensors,
   Bodies,