mujoco-react 9.5.0 → 10.0.0

package/src/hooks/useKeyboardIkTarget.ts

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import type { KeyboardIkTargetAction, KeyboardIkTargetBinding, KeyboardIkTargetConfig } from '../types';
+
+const DEFAULT_TRANSLATE_SPEED = 0.25;
+const DEFAULT_ROTATE_SPEED = 1.0;
+
+const _translation = new THREE.Vector3();
+const _axis = new THREE.Vector3();
+const _quat = new THREE.Quaternion();
+
+function actionSign(action: KeyboardIkTargetAction): 1 | -1 {
+  return action.endsWith('+') ? 1 : -1;
+}
+
+function actionBase(action: KeyboardIkTargetAction) {
+  return action.slice(0, -1);
+}
+
+function applyRotation(
+  target: THREE.Object3D,
+  action: KeyboardIkTargetAction,
+  amount: number,
+  frame: 'world' | 'target',
+) {
+  const base = actionBase(action);
+  if (base === 'pitch') {
+    _axis.set(1, 0, 0);
+  } else if (base === 'yaw') {
+    _axis.set(0, 1, 0);
+  } else if (base === 'roll') {
+    _axis.set(0, 0, 1);
+  } else {
+    return;
+  }
+
+  _quat.setFromAxisAngle(_axis, amount);
+  if (frame === 'target') {
+    target.quaternion.multiply(_quat);
+  } else {
+    target.quaternion.premultiply(_quat);
+  }
+}
+
+function addTranslation(action: KeyboardIkTargetAction, amount: number) {
+  switch (action) {
+    case 'x+':
+      _translation.x += amount;
+      break;
+    case 'x-':
+      _translation.x -= amount;
+      break;
+    case 'y+':
+      _translation.y += amount;
+      break;
+    case 'y-':
+      _translation.y -= amount;
+      break;
+    case 'z+':
+      _translation.z += amount;
+      break;
+    case 'z-':
+      _translation.z -= amount;
+      break;
+  }
+}
+
+/**
+ * Moves an existing IK target from keyboard input.
+ *
+ * This hook is intentionally robot-agnostic: it only edits the target owned by
+ * `useIkController`, then lets the normal IK solver write robot controls.
+ */
+export function useKeyboardIkTarget(config: KeyboardIkTargetConfig | null) {
+  const pressedRef = useRef(new Set<string>());
+  const wasActiveRef = useRef(false);
+  const configRef = useRef(config);
+  configRef.current = config;
+
+  const boundCodes = useMemo(() => {
+    return new Set((config?.bindings ?? []).map((binding) => binding.code));
+  }, [config?.bindings]);
+
+  useEffect(() => {
+    const onKeyDown = (event: KeyboardEvent) => {
+      const current = configRef.current;
+      if (!current || current.enabled === false || !boundCodes.has(event.code)) return;
+      if (current.preventDefault !== false) event.preventDefault();
+      pressedRef.current.add(event.code);
+    };
+    const onKeyUp = (event: KeyboardEvent) => {
+      const current = configRef.current;
+      if (boundCodes.has(event.code) && current?.preventDefault !== false) {
+        event.preventDefault();
+      }
+      pressedRef.current.delete(event.code);
+    };
+    const onBlur = () => {
+      pressedRef.current.clear();
+      wasActiveRef.current = false;
+    };
+
+    window.addEventListener('keydown', onKeyDown);
+    window.addEventListener('keyup', onKeyUp);
+    window.addEventListener('blur', onBlur);
+
+    return () => {
+      window.removeEventListener('keydown', onKeyDown);
+      window.removeEventListener('keyup', onKeyUp);
+      window.removeEventListener('blur', onBlur);
+    };
+  }, [boundCodes]);
+
+  useFrame((_state, delta) => {
+    const current = configRef.current;
+    const controller = current?.controller;
+    if (!current || current.enabled === false || !controller) {
+      wasActiveRef.current = false;
+      return;
+    }
+
+    const activeBindings: KeyboardIkTargetBinding[] = [];
+    for (const binding of current.bindings) {
+      if (pressedRef.current.has(binding.code)) activeBindings.push(binding);
+    }
+
+    if (activeBindings.length === 0) {
+      wasActiveRef.current = false;
+      return;
+    }
+
+    if (!wasActiveRef.current) {
+      if (current.syncOnStart !== false) controller.syncTargetToSite();
+      if (current.autoEnableIk !== false && !controller.ikEnabledRef.current) {
+        controller.setIkEnabled(true);
+      }
+    }
+    wasActiveRef.current = true;
+
+    const target = controller.ikTargetRef.current;
+    if (!target) return;
+
+    const frame = current.frame ?? 'world';
+    _translation.set(0, 0, 0);
+
+    for (const binding of activeBindings) {
+      const translateSpeed = binding.translateSpeed ?? current.translateSpeed ?? DEFAULT_TRANSLATE_SPEED;
+      const rotateSpeed = binding.rotateSpeed ?? current.rotateSpeed ?? DEFAULT_ROTATE_SPEED;
+      const amount = actionSign(binding.action) * delta;
+      const base = actionBase(binding.action);
+
+      if (base === 'x' || base === 'y' || base === 'z') {
+        addTranslation(binding.action, translateSpeed * delta);
+      } else {
+        applyRotation(target, binding.action, rotateSpeed * amount, frame);
+      }
+    }
+
+    if (_translation.lengthSq() > 0) {
+      if (frame === 'target') _translation.applyQuaternion(target.quaternion);
+      target.position.add(_translation);
+    }
+  });
+}

package/src/index.ts

@@ -91,6 +91,7 @@ export { useBodyState } from './hooks/useBodyState';
 export { useCtrl } from './hooks/useCtrl';
 export { useContacts, useContactEvents } from './hooks/useContacts';
 export { useKeyboardTeleop } from './hooks/useKeyboardTeleop';
+export { useKeyboardIkTarget } from './hooks/useKeyboardIkTarget';
 export { usePolicy } from './hooks/usePolicy';
 export { useObservation } from './hooks/useObservation';
 export { useTrajectoryPlayer } from './hooks/useTrajectoryPlayer';
@@ -211,6 +212,9 @@ export type {
   // Keyboard teleop
   KeyBinding,
   KeyboardTeleopConfig,
+  KeyboardIkTargetAction,
+  KeyboardIkTargetBinding,
+  KeyboardIkTargetConfig,
   // Policy
   PolicyConfig,
   PolicyVector,
@@ -293,11 +297,15 @@ export type {
   SensorHandle,
   BodyStateResult,
   JointStateResult,
+  JointStateKind,
+  JointStateOptions,
+  ScalarJointStateResult,
+  ArrayJointStateResult,
   // Register (type-safe named resources)
   Register,
-  RegisteredRobotMap,
-  RobotResource,
-  Robots,
+  RegisteredModelMap,
+  ModelResource,
+  Models,
   Actuators,
   Sensors,
   Bodies,
@@ -309,16 +317,16 @@ export type {
 } from './types';
 
 export {
-  registerRobotResources,
-  RobotResources,
-  RobotActuators,
-  RobotSensors,
-  RobotBodies,
-  RobotJoints,
-  RobotSites,
-  RobotGeoms,
-  RobotKeyframes,
-  RobotCameras,
+  registerModelResources,
+  ModelResources,
+  ModelActuators,
+  ModelSensors,
+  ModelBodies,
+  ModelJoints,
+  ModelSites,
+  ModelGeoms,
+  ModelKeyframes,
+  ModelCameras,
   SplatEnvironmentReadinessStatus,
 } from './types';
 

package/src/rendering/Reflector.ts

@@ -22,10 +22,13 @@ export interface ReflectorOptions {
 interface ReflectorMesh extends THREE.Mesh {
     type: string;
     material: THREE.MeshPhysicalMaterial;
-    // tslint:disable-next-line:no-any
-    onBeforeRender: (renderer: any, scene: any, camera: any) => void;
+    onBeforeRender: (renderer: THREE.WebGLRenderer, scene: THREE.Scene, camera: THREE.Camera) => void;
 }
 
+type CameraWithViewport = THREE.Camera & {
+    viewport?: THREE.Vector4;
+};
+
 /**
  * Reflector
  * Creates a reflective surface.
@@ -199,8 +202,7 @@ export class Reflector extends THREE.Mesh {
             renderer.setRenderTarget(currentRenderTarget);
 
             // Restore viewport
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const viewport = (camera as any).viewport;
+            const viewport = (camera as CameraWithViewport).viewport;
             if (viewport !== undefined) {
                 renderer.state.viewport(viewport);
             }
@@ -222,4 +224,4 @@ export class Reflector extends THREE.Mesh {
             mesh.material.dispose();
         }
     }
-}
+}

package/src/types.ts

@@ -17,7 +17,7 @@ import * as THREE from 'three';
  * ```ts
  * declare module 'mujoco-react' {
  *   interface Register {
- *     robots: {
+ *     models: {
  *       panda: {
  *         actuators: 'joint1' | 'joint2' | 'gripper';
  *         sensors: 'force_sensor' | 'torque_sensor';
@@ -35,45 +35,45 @@ import * as THREE from 'three';
  */
 export interface Register {}
 
-export type RegisteredRobotMap = Register extends { robots: infer T extends Record<string, Record<string, string>> }
+export type RegisteredModelMap = Register extends { models: infer T extends Record<string, Record<string, string>> }
   ? T
   : never;
-export type Robots = [RegisteredRobotMap] extends [never] ? string : Extract<keyof RegisteredRobotMap, string>;
-export type RobotResource<TRobot extends string, TKey extends string> =
-  [RegisteredRobotMap] extends [never]
+export type Models = [RegisteredModelMap] extends [never] ? string : Extract<keyof RegisteredModelMap, string>;
+export type ModelResource<TModel extends string, TKey extends string> =
+  [RegisteredModelMap] extends [never]
     ? string
-    : TRobot extends keyof RegisteredRobotMap
-      ? TKey extends keyof RegisteredRobotMap[TRobot]
-        ? RegisteredRobotMap[TRobot][TKey]
+    : TModel extends keyof RegisteredModelMap
+      ? TKey extends keyof RegisteredModelMap[TModel]
+        ? RegisteredModelMap[TModel][TKey]
         : string
       : never;
-export type RobotActuators<TRobot extends string> = RobotResource<TRobot, 'actuators'>;
-export type RobotSensors<TRobot extends string> = RobotResource<TRobot, 'sensors'>;
-export type RobotBodies<TRobot extends string> = RobotResource<TRobot, 'bodies'>;
-export type RobotJoints<TRobot extends string> = RobotResource<TRobot, 'joints'>;
-export type RobotSites<TRobot extends string> = RobotResource<TRobot, 'sites'>;
-export type RobotGeoms<TRobot extends string> = RobotResource<TRobot, 'geoms'>;
-export type RobotKeyframes<TRobot extends string> = RobotResource<TRobot, 'keyframes'>;
-export type RobotCameras<TRobot extends string> = RobotResource<TRobot, 'cameras'>;
+export type ModelActuators<TModel extends string> = ModelResource<TModel, 'actuators'>;
+export type ModelSensors<TModel extends string> = ModelResource<TModel, 'sensors'>;
+export type ModelBodies<TModel extends string> = ModelResource<TModel, 'bodies'>;
+export type ModelJoints<TModel extends string> = ModelResource<TModel, 'joints'>;
+export type ModelSites<TModel extends string> = ModelResource<TModel, 'sites'>;
+export type ModelGeoms<TModel extends string> = ModelResource<TModel, 'geoms'>;
+export type ModelKeyframes<TModel extends string> = ModelResource<TModel, 'keyframes'>;
+export type ModelCameras<TModel extends string> = ModelResource<TModel, 'cameras'>;
 
 export type RegisterResourceKey = 'actuators' | 'sensors' | 'bodies' | 'joints' | 'sites' | 'geoms' | 'keyframes' | 'cameras';
-export type RobotResourceObject<TRobot extends string, TKey extends RegisterResourceKey> =
-  string extends RobotResource<TRobot, TKey>
+export type ModelResourceObject<TModel extends string, TKey extends RegisterResourceKey> =
+  string extends ModelResource<TModel, TKey>
     ? Record<string, string>
-    : { readonly [K in RobotResource<TRobot, TKey>]: K };
-export type RobotResourceCategory<TKey extends RegisterResourceKey> =
-  string extends Robots
+    : { readonly [K in ModelResource<TModel, TKey>]: K };
+export type ModelResourceCategory<TKey extends RegisterResourceKey> =
+  string extends Models
     ? Record<string, Record<string, string>>
-    : { readonly [TRobot in Robots]: RobotResourceObject<TRobot, TKey> };
-export type RobotResourceRegistry =
-  string extends Robots
+    : { readonly [TModel in Models]: ModelResourceObject<TModel, TKey> };
+export type ModelResourceRegistry =
+  string extends Models
     ? Record<string, Record<RegisterResourceKey, Record<string, string>>>
-    : { readonly [TRobot in Robots]: { readonly [TKey in RegisterResourceKey]: RobotResourceObject<TRobot, TKey> } };
+    : { readonly [TModel in Models]: { readonly [TKey in RegisterResourceKey]: ModelResourceObject<TModel, TKey> } };
 
-type RuntimeRobotResources = Record<string, Record<RegisterResourceKey, Record<string, string>>>;
-type RuntimeRobotResourceRegistration = Readonly<Record<string, Readonly<Record<RegisterResourceKey, Readonly<Record<string, string>>>>>>;
+type RuntimeModelResources = Record<string, Record<RegisterResourceKey, Record<string, string>>>;
+type RuntimeModelResourceRegistration = Readonly<Record<string, Readonly<Record<RegisterResourceKey, Readonly<Record<string, string>>>>>>;
 
-const runtimeRobotResources: RuntimeRobotResources = {};
+const runtimeModelResources: RuntimeModelResources = {};
 const REGISTER_RESOURCE_KEYS: RegisterResourceKey[] = ['actuators', 'sensors', 'bodies', 'joints', 'sites', 'geoms', 'keyframes', 'cameras'];
 
 function createEmptyRuntimeResources(): Record<RegisterResourceKey, Record<string, string>> {
@@ -89,54 +89,54 @@ function createEmptyRuntimeResources(): Record<RegisterResourceKey, Record<strin
   };
 }
 
-export function registerRobotResources(resources: RuntimeRobotResourceRegistration): void {
-  for (const [robot, robotResources] of Object.entries(resources)) {
-    const existing = runtimeRobotResources[robot] ?? createEmptyRuntimeResources();
+export function registerModelResources(resources: RuntimeModelResourceRegistration): void {
+  for (const [model, modelResources] of Object.entries(resources)) {
+    const existing = runtimeModelResources[model] ?? createEmptyRuntimeResources();
     for (const key of REGISTER_RESOURCE_KEYS) {
-      existing[key] = { ...existing[key], ...(robotResources[key] ?? {}) };
+      existing[key] = { ...existing[key], ...(modelResources[key] ?? {}) };
     }
-    runtimeRobotResources[robot] = existing;
+    runtimeModelResources[model] = existing;
   }
 }
 
-function createResourceCategory<TKey extends RegisterResourceKey>(key: TKey): RobotResourceCategory<TKey> {
+function createResourceCategory<TKey extends RegisterResourceKey>(key: TKey): ModelResourceCategory<TKey> {
   return new Proxy({}, {
-    get(_target, robot) {
-      if (typeof robot !== 'string') return undefined;
-      return runtimeRobotResources[robot]?.[key] ?? {};
+    get(_target, model) {
+      if (typeof model !== 'string') return undefined;
+      return runtimeModelResources[model]?.[key] ?? {};
     },
     ownKeys() {
-      return Reflect.ownKeys(runtimeRobotResources);
+      return Reflect.ownKeys(runtimeModelResources);
     },
-    getOwnPropertyDescriptor(_target, robot) {
-      if (typeof robot !== 'string' || !(robot in runtimeRobotResources)) return undefined;
+    getOwnPropertyDescriptor(_target, model) {
+      if (typeof model !== 'string' || !(model in runtimeModelResources)) return undefined;
       return { enumerable: true, configurable: true };
     },
-  }) as RobotResourceCategory<TKey>;
+  }) as ModelResourceCategory<TKey>;
 }
 
-export const RobotResources: RobotResourceRegistry = new Proxy(runtimeRobotResources, {
-  get(target, robot) {
-    if (typeof robot !== 'string') return undefined;
-    return target[robot] ?? createEmptyRuntimeResources();
+export const ModelResources: ModelResourceRegistry = new Proxy(runtimeModelResources, {
+  get(target, model) {
+    if (typeof model !== 'string') return undefined;
+    return target[model] ?? createEmptyRuntimeResources();
   },
   ownKeys(target) {
     return Reflect.ownKeys(target);
   },
-  getOwnPropertyDescriptor(target, robot) {
-    if (typeof robot !== 'string' || !(robot in target)) return undefined;
+  getOwnPropertyDescriptor(target, model) {
+    if (typeof model !== 'string' || !(model in target)) return undefined;
     return { enumerable: true, configurable: true };
   },
-}) as RobotResourceRegistry;
+}) as ModelResourceRegistry;
 
-export const RobotActuators: RobotResourceCategory<'actuators'> = createResourceCategory('actuators');
-export const RobotSensors: RobotResourceCategory<'sensors'> = createResourceCategory('sensors');
-export const RobotBodies: RobotResourceCategory<'bodies'> = createResourceCategory('bodies');
-export const RobotJoints: RobotResourceCategory<'joints'> = createResourceCategory('joints');
-export const RobotSites: RobotResourceCategory<'sites'> = createResourceCategory('sites');
-export const RobotGeoms: RobotResourceCategory<'geoms'> = createResourceCategory('geoms');
-export const RobotKeyframes: RobotResourceCategory<'keyframes'> = createResourceCategory('keyframes');
-export const RobotCameras: RobotResourceCategory<'cameras'> = createResourceCategory('cameras');
+export const ModelActuators: ModelResourceCategory<'actuators'> = createResourceCategory('actuators');
+export const ModelSensors: ModelResourceCategory<'sensors'> = createResourceCategory('sensors');
+export const ModelBodies: ModelResourceCategory<'bodies'> = createResourceCategory('bodies');
+export const ModelJoints: ModelResourceCategory<'joints'> = createResourceCategory('joints');
+export const ModelSites: ModelResourceCategory<'sites'> = createResourceCategory('sites');
+export const ModelGeoms: ModelResourceCategory<'geoms'> = createResourceCategory('geoms');
+export const ModelKeyframes: ModelResourceCategory<'keyframes'> = createResourceCategory('keyframes');
+export const ModelCameras: ModelResourceCategory<'cameras'> = createResourceCategory('cameras');
 
 export type Actuators = Register extends { actuators: infer T extends string } ? T : string;
 export type Sensors = Register extends { sensors: infer T extends string } ? T : string;
@@ -516,6 +516,14 @@ export interface IkConfig {
   ikSolveFn?: IKSolveFn;
   /** DLS damping. Default: 0.01. */
   damping?: number;
+  /** Position error weight for the built-in DLS solver. Default: 1. */
+  posWeight?: number;
+  /** Orientation error weight for the built-in DLS solver. Default: 0.3. */
+  rotWeight?: number;
+  /** Solver convergence tolerance. Default: 1e-3. */
+  tolerance?: number;
+  /** Finite-difference step used by the built-in DLS solver. Default: 1e-6. */
+  epsilon?: number;
   /** Max solver iterations. Default: 50. */
   maxIterations?: number;
 }
@@ -864,6 +872,48 @@ export interface IkGizmoDragInput {
   quaternion: THREE.Quaternion;
 }
 
+export type KeyboardIkTargetAction =
+  | 'x+'
+  | 'x-'
+  | 'y+'
+  | 'y-'
+  | 'z+'
+  | 'z-'
+  | 'pitch+'
+  | 'pitch-'
+  | 'yaw+'
+  | 'yaw-'
+  | 'roll+'
+  | 'roll-';
+
+export interface KeyboardIkTargetBinding {
+  /** KeyboardEvent.code, e.g. `KeyW`, `ArrowUp`, `Space`. */
+  code: string;
+  action: KeyboardIkTargetAction;
+  /** Override translation speed in meters/second for this binding. */
+  translateSpeed?: number;
+  /** Override rotation speed in radians/second for this binding. */
+  rotateSpeed?: number;
+}
+
+export interface KeyboardIkTargetConfig {
+  controller: IkContextValue | null;
+  bindings: KeyboardIkTargetBinding[];
+  enabled?: boolean;
+  /** Default translation speed in meters/second. Default: 0.25. */
+  translateSpeed?: number;
+  /** Default rotation speed in radians/second. Default: 1.0. */
+  rotateSpeed?: number;
+  /** Apply translation and rotation axes in world or current target space. Default: `world`. */
+  frame?: 'world' | 'target';
+  /** Enable IK while keys are active. Default: true. */
+  autoEnableIk?: boolean;
+  /** Sync target to current site when keyboard control starts. Default: true. */
+  syncOnStart?: boolean;
+  /** Prevent browser default behavior for bound keys. Default: true. */
+  preventDefault?: boolean;
+}
+
 export interface DragInteractionProps {
   stiffness?: number;
   showArrow?: boolean;
@@ -1482,7 +1532,30 @@ export interface BodyStateResult {
   angularVelocity: React.RefObject<THREE.Vector3>;
 }
 
+export type JointStateKind = 'auto' | 'scalar' | 'array';
+
+export interface JointStateOptions {
+  /**
+   * Expected joint value shape.
+   *
+   * - `auto`: scalar joints return numbers, ball/free joints return Float64Array.
+   * - `scalar`: return numeric refs for hinge/slide joints.
+   * - `array`: return Float64Array refs for ball/free joints.
+   */
+  kind?: JointStateKind;
+}
+
 export interface JointStateResult {
   position: React.RefObject<number | Float64Array>;
   velocity: React.RefObject<number | Float64Array>;
 }
+
+export interface ScalarJointStateResult {
+  position: React.RefObject<number>;
+  velocity: React.RefObject<number>;
+}
+
+export interface ArrayJointStateResult {
+  position: React.RefObject<Float64Array>;
+  velocity: React.RefObject<Float64Array>;
+}

package/src/vite.ts

@@ -221,21 +221,21 @@ function renderRegister(
   const fields = REGISTER_KEYS
     .filter((key) => names[key].size > 0)
     .map((key) => `    ${key}: ${renderUnion(names[key])};`);
-  const robots = models
-    .map((model) => `      ${quoteProperty(model.id)}: {\n${renderRobotFields(model.names)}\n      };`);
+  const modelFields = models
+    .map((model) => `      ${quoteProperty(model.id)}: {\n${renderModelFields(model.names)}\n      };`);
   const namespaceAliases = renderNamespaceAliases(models);
-  const registerImport = declarationsOnly ? '' : `import { registerRobotResources } from '${moduleName}';\n`;
-  const resources = declarationsOnly ? '' : `${renderResourceTypes(models)}\n\n${renderResourceConstants(models)}\n\nregisterRobotResources(generatedRobotResources);\n\n`;
+  const registerImport = declarationsOnly ? '' : `import { registerModelResources } from '${moduleName}';\n`;
+  const resources = declarationsOnly ? '' : `${renderResourceTypes(models)}\n\n${renderResourceConstants(models)}\n\nregisterModelResources(generatedModelResources);\n\n`;
 
   return `// Auto-generated by mujoco-react. Do not edit.
 // Regenerate by running Vite with the mujocoReact() plugin or \`mujoco-react codegen\`.
 
-${registerImport}import type { RobotResource } from '${moduleName}';
+${registerImport}import type { ModelResource } from '${moduleName}';
 
 ${resources}declare module '${moduleName}' {
   interface Register {
-    robots: {
-${robots.join('\n')}
+    models: {
+${modelFields.join('\n')}
     };
 ${fields.join('\n')}
   }
@@ -249,7 +249,7 @@ function renderResourceTypes(models: readonly ModelEntry[]): string {
   const modelTypes = models
     .map((model) => `  readonly ${quoteProperty(model.id)}: {\n${renderResourceTypeFields(model.names)}\n  };`)
     .join('\n');
-  return `type GeneratedRobotResources = {\n${modelTypes}\n};`;
+  return `type GeneratedModelResources = {\n${modelTypes}\n};`;
 }
 
 function renderResourceTypeFields(names: Record<RegisterKey, Set<string>>): string {
@@ -268,7 +268,7 @@ function renderResourceConstants(models: readonly ModelEntry[]): string {
   const entries = models
     .map((model) => `  ${quoteProperty(model.id)}: {\n${renderResourceConstantFields(model.names)}\n  },`)
     .join('\n');
-  return `const generatedRobotResources: GeneratedRobotResources = {\n${entries}\n};`;
+  return `const generatedModelResources: GeneratedModelResources = {\n${entries}\n};`;
 }
 
 function renderResourceConstantFields(names: Record<RegisterKey, Set<string>>): string {
@@ -283,7 +283,7 @@ function renderResourceObject(values: Set<string>): string {
   return entries.length > 0 ? `{\n${entries.join('\n')}\n    }` : '{}';
 }
 
-function renderRobotFields(names: Record<RegisterKey, Set<string>>): string {
+function renderModelFields(names: Record<RegisterKey, Set<string>>): string {
   return REGISTER_KEYS
     .map((key) => `        ${key}: ${names[key].size > 0 ? renderUnion(names[key]) : 'never'};`)
     .join('\n');
@@ -295,23 +295,23 @@ function renderUnion(values: Set<string>): string {
 
 function renderNamespaceAliases(models: readonly ModelEntry[]): string {
   const namespaces: Record<RegisterKey, string> = {
-    actuators: 'RobotActuators',
-    sensors: 'RobotSensors',
-    bodies: 'RobotBodies',
-    joints: 'RobotJoints',
-    sites: 'RobotSites',
-    geoms: 'RobotGeoms',
-    keyframes: 'RobotKeyframes',
-    cameras: 'RobotCameras',
+    actuators: 'ModelActuators',
+    sensors: 'ModelSensors',
+    bodies: 'ModelBodies',
+    joints: 'ModelJoints',
+    sites: 'ModelSites',
+    geoms: 'ModelGeoms',
+    keyframes: 'ModelKeyframes',
+    cameras: 'ModelCameras',
   };
 
   const blocks = REGISTER_KEYS
     .map((key) => {
-      const aliases = models
+      const modelAliases = models
         .filter((model) => isIdentifier(model.id))
-        .map((model) => `    export type ${model.id} = RobotResource<'${escapeTs(model.id)}', '${key}'>;`);
-      if (aliases.length === 0) return '';
-      return `  export namespace ${namespaces[key]} {\n${aliases.join('\n')}\n  }`;
+        .map((model) => `    export type ${model.id} = ModelResource<'${escapeTs(model.id)}', '${key}'>;`);
+      if (modelAliases.length === 0) return '';
+      return `  export namespace ${namespaces[key]} {\n${modelAliases.join('\n')}\n  }`;
     })
     .filter(Boolean)
     .join('\n\n');